NDIS_STATUS NTAPI MiniportInitialize ( OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext ) { PRTL_ADAPTER adapter; NDIS_STATUS status; UINT i; PNDIS_RESOURCE_LIST resourceList; UINT resourceListSize; // // Make sure the medium is supported // for (i = 0; i < MediumArraySize; i++) { if (MediumArray[i] == NdisMedium802_3) { *SelectedMediumIndex = i; break; } } if (i == MediumArraySize) { NDIS_DbgPrint(MIN_TRACE, ("802.3 medium was not found in the medium array\n")); return NDIS_STATUS_UNSUPPORTED_MEDIA; } // // Allocate our adapter context // status = NdisAllocateMemoryWithTag((PVOID*)&adapter, sizeof(*adapter), ADAPTER_TAG); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate adapter context\n")); return NDIS_STATUS_RESOURCES; } RtlZeroMemory(adapter, sizeof(*adapter)); adapter->MiniportAdapterHandle = MiniportAdapterHandle; NdisAllocateSpinLock(&adapter->Lock); // // Notify NDIS of some characteristics of our NIC // NdisMSetAttributesEx(MiniportAdapterHandle, adapter, 0, NDIS_ATTRIBUTE_BUS_MASTER, NdisInterfacePci); // // Get our resources for IRQ and IO base information // resourceList = NULL; resourceListSize = 0; NdisMQueryAdapterResources(&status, WrapperConfigurationContext, resourceList, &resourceListSize); if (status != NDIS_STATUS_RESOURCES) { NDIS_DbgPrint(MIN_TRACE, ("Unexpected failure of NdisMQueryAdapterResources #1\n")); status = NDIS_STATUS_FAILURE; goto Cleanup; } status = NdisAllocateMemoryWithTag((PVOID*)&resourceList, resourceListSize, RESOURCE_LIST_TAG); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Failed to allocate resource list\n")); goto Cleanup; } NdisMQueryAdapterResources(&status, WrapperConfigurationContext, resourceList, &resourceListSize); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unexpected failure of NdisMQueryAdapterResources #2\n")); goto Cleanup; } ASSERT(resourceList->Version == 1); ASSERT(resourceList->Revision == 1); for (i = 0; i < resourceList->Count; i++) { switch (resourceList->PartialDescriptors[i].Type) { case CmResourceTypePort: ASSERT(adapter->IoRangeStart == 0); ASSERT(resourceList->PartialDescriptors[i].u.Port.Start.HighPart == 0); adapter->IoRangeStart = resourceList->PartialDescriptors[i].u.Port.Start.LowPart; adapter->IoRangeLength = resourceList->PartialDescriptors[i].u.Port.Length; NDIS_DbgPrint(MID_TRACE, ("I/O port range is %p to %p\n", adapter->IoRangeStart, adapter->IoRangeStart + adapter->IoRangeLength)); break; case CmResourceTypeInterrupt: ASSERT(adapter->InterruptVector == 0); ASSERT(adapter->InterruptLevel == 0); adapter->InterruptVector = resourceList->PartialDescriptors[i].u.Interrupt.Vector; adapter->InterruptLevel = resourceList->PartialDescriptors[i].u.Interrupt.Level; adapter->InterruptShared = (resourceList->PartialDescriptors[i].ShareDisposition == CmResourceShareShared); adapter->InterruptFlags = resourceList->PartialDescriptors[i].Flags; NDIS_DbgPrint(MID_TRACE, ("IRQ vector is %d\n", adapter->InterruptVector)); break; default: NDIS_DbgPrint(MIN_TRACE, ("Unrecognized resource type: 0x%x\n", resourceList->PartialDescriptors[i].Type)); break; } } NdisFreeMemory(resourceList, resourceListSize, 0); resourceList = NULL; if (adapter->IoRangeStart == 0 || adapter->InterruptVector == 0) { NDIS_DbgPrint(MIN_TRACE, ("Adapter didn't receive enough resources\n")); goto Cleanup; } // // Allocate the DMA resources // status = NdisMInitializeScatterGatherDma(MiniportAdapterHandle, FALSE, // RTL8139 only supports 32-bit addresses MAXIMUM_FRAME_SIZE); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to configure DMA\n")); goto Cleanup; } adapter->ReceiveBufferLength = FULL_RECEIVE_BUFFER_SIZE; NdisMAllocateSharedMemory(MiniportAdapterHandle, adapter->ReceiveBufferLength, FALSE, (PVOID*)&adapter->ReceiveBuffer, &adapter->ReceiveBufferPa); if (adapter->ReceiveBuffer == NULL) { NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate receive buffer\n")); status = NDIS_STATUS_RESOURCES; goto Cleanup; } NdisMAllocateSharedMemory(MiniportAdapterHandle, MINIMUM_FRAME_SIZE * TX_DESC_COUNT, FALSE, (PVOID*)&adapter->RuntTxBuffers, &adapter->RuntTxBuffersPa); if (adapter->RuntTxBuffers == NULL) { NDIS_DbgPrint(MIN_TRACE, ("Unable to allocate runt TX buffer\n")); status = NDIS_STATUS_RESOURCES; goto Cleanup; } // // Register the I/O port range and configure the NIC // status = NdisMRegisterIoPortRange((PVOID*)&adapter->IoBase, MiniportAdapterHandle, adapter->IoRangeStart, adapter->IoRangeLength); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to register IO port range (0x%x)\n", status)); goto Cleanup; } // // Adapter setup // status = NICPowerOn(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to power on NIC (0x%x)\n", status)); goto Cleanup; } status = NICSoftReset(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to reset the NIC (0x%x)\n", status)); goto Cleanup; } status = NICGetPermanentMacAddress(adapter, adapter->PermanentMacAddress); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to get the fixed MAC address (0x%x)\n", status)); goto Cleanup; } RtlCopyMemory(adapter->CurrentMacAddress, adapter->PermanentMacAddress, IEEE_802_ADDR_LENGTH); // // Update link state and speed // NICUpdateLinkStatus(adapter); status = NICRegisterReceiveBuffer(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to setup receive buffer (0x%x)\n", status)); goto Cleanup; } // // We're ready to handle interrupts now // status = NdisMRegisterInterrupt(&adapter->Interrupt, MiniportAdapterHandle, adapter->InterruptVector, adapter->InterruptLevel, TRUE, // We always want ISR calls adapter->InterruptShared, (adapter->InterruptFlags & CM_RESOURCE_INTERRUPT_LATCHED) ? NdisInterruptLatched : NdisInterruptLevelSensitive); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to register interrupt (0x%x)\n", status)); goto Cleanup; } adapter->InterruptRegistered = TRUE; // // Enable interrupts on the NIC // adapter->InterruptMask = DEFAULT_INTERRUPT_MASK; status = NICApplyInterruptMask(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to apply interrupt mask (0x%x)\n", status)); goto Cleanup; } // // Turn on TX and RX now // status = NICEnableTxRx(adapter); if (status != NDIS_STATUS_SUCCESS) { NDIS_DbgPrint(MIN_TRACE, ("Unable to enable TX and RX (0x%x)\n", status)); goto Cleanup; } return NDIS_STATUS_SUCCESS; Cleanup: if (resourceList != NULL) { NdisFreeMemory(resourceList, resourceListSize, 0); } if (adapter != NULL) { MiniportHalt(adapter); } return status; }
/****************************************************** Required NDIS procedure Allocates and initializes adapter context Finally sets send and receive to Enabled state and reports connect Returns: NDIS_STATUS SUCCESS or some error code *******************************************************/ static NDIS_STATUS ParaNdis5_Initialize(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 = NDIS_STATUS_UNSUPPORTED_MEDIA; PARANDIS_ADAPTER *pContext = NULL; UINT i; for(i = 0; i < MediumArraySize; ++i) { if(MediumArray[i] == NdisMedium802_3) { *SelectedMediumIndex = i; status = NDIS_STATUS_SUCCESS; break; } } if (status == NDIS_STATUS_SUCCESS) { pContext = (PARANDIS_ADAPTER *)ParaNdis_AllocateMemory(NULL, sizeof(PARANDIS_ADAPTER)); if (!pContext) { status = NDIS_STATUS_RESOURCES; } } if (status == NDIS_STATUS_SUCCESS) { PVOID pResourceList = &status; UINT uSize = 0; NdisZeroMemory(pContext, sizeof(PARANDIS_ADAPTER)); pContext->ulUniqueID = InterlockedIncrement(&gID); pContext->DriverHandle = DriverHandle; pContext->MiniportHandle = MiniportAdapterHandle; pContext->WrapperConfigurationHandle = WrapperConfigurationContext; NdisMQueryAdapterResources(&status, WrapperConfigurationContext, pResourceList, &uSize); if (uSize > 0) pResourceList = ParaNdis_AllocateMemory(MiniportAdapterHandle, uSize); else pResourceList = NULL; if (!pResourceList) status = uSize > 0 ? NDIS_STATUS_RESOURCES : NDIS_STATUS_FAILURE; else { ULONG attributes; attributes = NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_BUS_MASTER; // in XP SP2, if this flag is NOT set, the NDIS halts miniport // upon transition to S1..S4. // it seems that XP SP3 ignores it and always sends SET_POWER to D3 #ifndef NO_XP_POWER_MANAGEMENT attributes |= NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND; #endif #ifdef NDIS50_MINIPORT //TODO: this is wrong, I think // this API is for XP and // it should be used only if you never need virtual addresses of sent buffers // so I comment it out //attributes |= NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS; #endif NdisMSetAttributesEx( MiniportAdapterHandle, pContext, 0, attributes, NdisInterfacePci); NdisMQueryAdapterResources(&status, WrapperConfigurationContext, pResourceList, &uSize); status = ParaNdis_InitializeContext(pContext, (PNDIS_RESOURCE_LIST)pResourceList); NdisFreeMemory(pResourceList, 0, 0); } } if (status == NDIS_STATUS_SUCCESS) { status = ParaNdis_FinishInitialization(pContext); if (status == NDIS_STATUS_SUCCESS) { #ifdef NDIS50_MINIPORT NdisMRegisterAdapterShutdownHandler( MiniportAdapterHandle, pContext, (ADAPTER_SHUTDOWN_HANDLER)ParaNdis5_Shutdown); #endif //NDIS50_MINIPORT ParaNdis_DebugRegisterMiniport(pContext, TRUE); ParaNdis_IndicateConnect(pContext, FALSE, TRUE); ParaNdis5_StopSend(pContext, FALSE, NULL); ParaNdis5_StopReceive(pContext, FALSE, NULL); if (!pContext->ulMilliesToConnect) { ParaNdis_ReportLinkStatus(pContext, FALSE); } else { NdisSetTimer(&pContext->ConnectTimer, pContext->ulMilliesToConnect); } } else { ParaNdis_CleanupContext(pContext); } } if (status != NDIS_STATUS_SUCCESS && pContext) { NdisFreeMemory(pContext, 0, 0); } DEBUG_EXIT_STATUS(0, status); return status; }
NDIS_STATUS MPInitialize( OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext ) /*++ Routine Description: This is the initialize handler which gets called as a result of the BindAdapter handler calling NdisIMInitializeDeviceInstanceEx. The context parameter which we pass there is the adapter structure which we retrieve here. Arguments: OpenErrorStatus Not used by us. SelectedMediumIndex Place-holder for what media we are using MediumArray Array of ndis media passed down to us to pick from MediumArraySize Size of the array MiniportAdapterHandle The handle NDIS uses to refer to us WrapperConfigurationContext For use by NdisOpenConfiguration Return Value: NDIS_STATUS_SUCCESS unless something goes wrong --*/ { UINT i; PADAPT pAdapt; NDIS_STATUS Status = NDIS_STATUS_FAILURE; NDIS_MEDIUM Medium; UNREFERENCED_PARAMETER(WrapperConfigurationContext); do { // // Start off by retrieving our adapter context and storing // the Miniport handle in it. // pAdapt = NdisIMGetDeviceContext(MiniportAdapterHandle); pAdapt->MiniportHandle = MiniportAdapterHandle; DBGPRINT(("==> Miniport Initialize: Adapt %p\n", pAdapt)); // // Usually we export the medium type of the adapter below as our // virtual miniport's medium type. However if the adapter below us // is a WAN device, then we claim to be of medium type 802.3. // Medium = pAdapt->Medium; if (Medium == NdisMediumWan) { Medium = NdisMedium802_3; } for (i = 0; i < MediumArraySize; i++) { if (MediumArray[i] == Medium) { *SelectedMediumIndex = i; break; } } if (i == MediumArraySize) { Status = NDIS_STATUS_UNSUPPORTED_MEDIA; break; } // // Set the attributes now. NDIS_ATTRIBUTE_DESERIALIZE enables us // to make up-calls to NDIS without having to call NdisIMSwitchToMiniport // or NdisIMQueueCallBack. This also forces us to protect our data using // spinlocks where appropriate. Also in this case NDIS does not queue // packets on our behalf. Since this is a very simple pass-thru // miniport, we do not have a need to protect anything. However in // a general case there will be a need to use per-adapter spin-locks // for the packet queues at the very least. // NdisMSetAttributesEx(MiniportAdapterHandle, pAdapt, 0, // CheckForHangTimeInSeconds NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT | NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT| NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER | NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND, 0); // // Initialize LastIndicatedStatus to be NDIS_STATUS_MEDIA_CONNECT // pAdapt->LastIndicatedStatus = NDIS_STATUS_MEDIA_CONNECT; // // Initialize the power states for both the lower binding (PTDeviceState) // and our miniport edge to Powered On. // pAdapt->MPDeviceState = NdisDeviceStateD0; pAdapt->PTDeviceState = NdisDeviceStateD0; // // Add this adapter to the global pAdapt List // NdisAcquireSpinLock(&GlobalLock); pAdapt->Next = pAdaptList; pAdaptList = pAdapt; NdisReleaseSpinLock(&GlobalLock); // // Create an ioctl interface // (VOID)PtRegisterDevice(); Status = NDIS_STATUS_SUCCESS; } while (FALSE); // // If we had received an UnbindAdapter notification on the underlying // adapter, we would have blocked that thread waiting for the IM Init // process to complete. Wake up any such thread. // ASSERT(pAdapt->MiniportInitPending == TRUE); pAdapt->MiniportInitPending = FALSE; NdisSetEvent(&pAdapt->MiniportInitEvent); DBGPRINT(("<== Miniport Initialize: Adapt %p, Status %x\n", pAdapt, Status)); *OpenErrorStatus = Status; return Status; }
// Called at <= DISPATCH_LEVEL static NDIS_STATUS XenNet_Init( 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; BOOLEAN medium_found = FALSE; struct xennet_info *xi = NULL; UINT nrl_length; PNDIS_RESOURCE_LIST nrl; PCM_PARTIAL_RESOURCE_DESCRIPTOR prd; KIRQL irq_level = 0; ULONG irq_vector = 0; ULONG irq_mode = 0; NDIS_HANDLE config_handle; NDIS_STRING config_param_name; PNDIS_CONFIGURATION_PARAMETER config_param; ULONG i; PUCHAR ptr; UCHAR type; PCHAR setting, value; ULONG length; //CHAR buf[128]; PVOID network_address; UINT network_address_length; BOOLEAN qemu_hide_filter = FALSE; ULONG qemu_hide_flags_value = 0; UNREFERENCED_PARAMETER(OpenErrorStatus); FUNCTION_ENTER(); KdPrint((__DRIVER_NAME " IRQL = %d\n", KeGetCurrentIrql())); /* deal with medium stuff */ for (i = 0; i < MediumArraySize; i++) { if (MediumArray[i] == NdisMedium802_3) { medium_found = TRUE; break; } } if (!medium_found) { KdPrint(("NIC_MEDIA_TYPE not in MediumArray\n")); return NDIS_STATUS_UNSUPPORTED_MEDIA; } *SelectedMediumIndex = i; /* Alloc memory for adapter private info */ status = NdisAllocateMemoryWithTag((PVOID)&xi, sizeof(*xi), XENNET_POOL_TAG); if (!NT_SUCCESS(status)) { KdPrint(("NdisAllocateMemoryWithTag failed with 0x%x\n", status)); status = NDIS_STATUS_RESOURCES; goto err; } RtlZeroMemory(xi, sizeof(*xi)); xi->adapter_handle = MiniportAdapterHandle; xi->rx_target = RX_DFL_MIN_TARGET; xi->rx_min_target = RX_DFL_MIN_TARGET; xi->rx_max_target = RX_MAX_TARGET; xi->inactive = TRUE; NdisMSetAttributesEx(xi->adapter_handle, (NDIS_HANDLE) xi, 0, 0 /* the last zero is to give the next | something to | with */ #ifdef NDIS51_MINIPORT |NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS #endif |NDIS_ATTRIBUTE_DESERIALIZE |NDIS_ATTRIBUTE_SURPRISE_REMOVE_OK, NdisInterfaceInternal); /* PnpBus option doesn't exist... */ xi->multicast_list_size = 0; xi->current_lookahead = MIN_LOOKAHEAD_LENGTH; nrl_length = 0; NdisMQueryAdapterResources(&status, WrapperConfigurationContext, NULL, (PUINT)&nrl_length); KdPrint((__DRIVER_NAME " nrl_length = %d\n", nrl_length)); status = NdisAllocateMemoryWithTag((PVOID)&nrl, nrl_length, XENNET_POOL_TAG); if (status != NDIS_STATUS_SUCCESS) { KdPrint((__DRIVER_NAME " Could not get allocate memory for Adapter Resources 0x%x\n", status)); return NDIS_STATUS_RESOURCES; } NdisMQueryAdapterResources(&status, WrapperConfigurationContext, nrl, (PUINT)&nrl_length); if (status != NDIS_STATUS_SUCCESS) { KdPrint((__DRIVER_NAME " Could not get Adapter Resources 0x%x\n", status)); return NDIS_STATUS_RESOURCES; } xi->event_channel = 0; xi->config_csum = 1; xi->config_csum_rx_check = 1; xi->config_sg = 1; xi->config_gso = 61440; xi->config_page = NULL; xi->config_rx_interrupt_moderation = 0; for (i = 0; i < nrl->Count; i++) { prd = &nrl->PartialDescriptors[i]; switch(prd->Type) { case CmResourceTypeInterrupt: irq_vector = prd->u.Interrupt.Vector; irq_level = (KIRQL)prd->u.Interrupt.Level; irq_mode = (prd->Flags & CM_RESOURCE_INTERRUPT_LATCHED)?NdisInterruptLatched:NdisInterruptLevelSensitive; KdPrint((__DRIVER_NAME " irq_vector = %03x, irq_level = %03x, irq_mode = %s\n", irq_vector, irq_level, (irq_mode == NdisInterruptLatched)?"NdisInterruptLatched":"NdisInterruptLevelSensitive")); break; case CmResourceTypeMemory: if (xi->config_page) { KdPrint(("More than one memory range\n")); return NDIS_STATUS_RESOURCES; } else { status = NdisMMapIoSpace(&xi->config_page, MiniportAdapterHandle, prd->u.Memory.Start, prd->u.Memory.Length); if (!NT_SUCCESS(status)) { KdPrint(("NdisMMapIoSpace failed with 0x%x\n", status)); NdisFreeMemory(nrl, nrl_length, 0); return NDIS_STATUS_RESOURCES; } } break; } } NdisFreeMemory(nrl, nrl_length, 0); if (!xi->config_page) { KdPrint(("No config page given\n")); return NDIS_STATUS_RESOURCES; } KeInitializeDpc(&xi->suspend_dpc, XenNet_SuspendResume, xi); KeInitializeSpinLock(&xi->resume_lock); KeInitializeDpc(&xi->rxtx_dpc, XenNet_RxTxDpc, xi); KeSetTargetProcessorDpc(&xi->rxtx_dpc, 0); KeSetImportanceDpc(&xi->rxtx_dpc, HighImportance); NdisMGetDeviceProperty(MiniportAdapterHandle, &xi->pdo, &xi->fdo, &xi->lower_do, NULL, NULL); xi->packet_filter = 0; status = IoGetDeviceProperty(xi->pdo, DevicePropertyDeviceDescription, NAME_SIZE, xi->dev_desc, &length); if (!NT_SUCCESS(status)) { KdPrint(("IoGetDeviceProperty failed with 0x%x\n", status)); status = NDIS_STATUS_FAILURE; goto err; } ptr = xi->config_page; while((type = GET_XEN_INIT_RSP(&ptr, (PVOID)&setting, (PVOID)&value, (PVOID)&value)) != XEN_INIT_TYPE_END) { switch(type) { case XEN_INIT_TYPE_VECTORS: KdPrint((__DRIVER_NAME " XEN_INIT_TYPE_VECTORS\n")); if (((PXENPCI_VECTORS)value)->length != sizeof(XENPCI_VECTORS) || ((PXENPCI_VECTORS)value)->magic != XEN_DATA_MAGIC) { KdPrint((__DRIVER_NAME " vectors mismatch (magic = %08x, length = %d)\n", ((PXENPCI_VECTORS)value)->magic, ((PXENPCI_VECTORS)value)->length)); FUNCTION_EXIT(); return NDIS_STATUS_FAILURE; } else memcpy(&xi->vectors, value, sizeof(XENPCI_VECTORS)); break; case XEN_INIT_TYPE_STATE_PTR: KdPrint((__DRIVER_NAME " XEN_INIT_TYPE_DEVICE_STATE - %p\n", PtrToUlong(value))); xi->device_state = (PXENPCI_DEVICE_STATE)value; break; case XEN_INIT_TYPE_QEMU_HIDE_FLAGS: qemu_hide_flags_value = PtrToUlong(value); break; case XEN_INIT_TYPE_QEMU_HIDE_FILTER: qemu_hide_filter = TRUE; break; default: KdPrint((__DRIVER_NAME " XEN_INIT_TYPE_%d\n", type)); break; } } if ((qemu_hide_flags_value & QEMU_UNPLUG_ALL_IDE_DISKS) || qemu_hide_filter) xi->inactive = FALSE; xi->power_state = NdisDeviceStateD0; xi->power_workitem = IoAllocateWorkItem(xi->fdo); // now build config page NdisOpenConfiguration(&status, &config_handle, WrapperConfigurationContext); if (!NT_SUCCESS(status)) { KdPrint(("Could not open config in registry (%08x)\n", status)); status = NDIS_STATUS_RESOURCES; goto err; } NdisInitUnicodeString(&config_param_name, L"ScatterGather"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read ScatterGather value (%08x)\n", status)); xi->config_sg = 1; } else { KdPrint(("ScatterGather = %d\n", config_param->ParameterData.IntegerData)); xi->config_sg = config_param->ParameterData.IntegerData; } NdisInitUnicodeString(&config_param_name, L"LargeSendOffload"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read LargeSendOffload value (%08x)\n", status)); xi->config_gso = 0; } else { KdPrint(("LargeSendOffload = %d\n", config_param->ParameterData.IntegerData)); xi->config_gso = config_param->ParameterData.IntegerData; if (xi->config_gso > 61440) { xi->config_gso = 61440; KdPrint(("(clipped to %d)\n", xi->config_gso)); } } NdisInitUnicodeString(&config_param_name, L"ChecksumOffload"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read ChecksumOffload value (%08x)\n", status)); xi->config_csum = 1; } else { KdPrint(("ChecksumOffload = %d\n", config_param->ParameterData.IntegerData)); xi->config_csum = !!config_param->ParameterData.IntegerData; } NdisInitUnicodeString(&config_param_name, L"ChecksumOffloadRxCheck"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read ChecksumOffloadRxCheck value (%08x)\n", status)); xi->config_csum_rx_check = 1; } else { KdPrint(("ChecksumOffloadRxCheck = %d\n", config_param->ParameterData.IntegerData)); xi->config_csum_rx_check = !!config_param->ParameterData.IntegerData; } NdisInitUnicodeString(&config_param_name, L"ChecksumOffloadDontFix"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read ChecksumOffloadDontFix value (%08x)\n", status)); xi->config_csum_rx_dont_fix = 0; } else { KdPrint(("ChecksumOffloadDontFix = %d\n", config_param->ParameterData.IntegerData)); xi->config_csum_rx_dont_fix = !!config_param->ParameterData.IntegerData; } NdisInitUnicodeString(&config_param_name, L"MTU"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read MTU value (%08x)\n", status)); xi->config_mtu = 1500; } else { KdPrint(("MTU = %d\n", config_param->ParameterData.IntegerData)); xi->config_mtu = config_param->ParameterData.IntegerData; } NdisInitUnicodeString(&config_param_name, L"RxInterruptModeration"); NdisReadConfiguration(&status, &config_param, config_handle, &config_param_name, NdisParameterInteger); if (!NT_SUCCESS(status)) { KdPrint(("Could not read RxInterruptModeration value (%08x)\n", status)); xi->config_rx_interrupt_moderation = 1500; } else { KdPrint(("RxInterruptModeration = %d\n", config_param->ParameterData.IntegerData)); xi->config_rx_interrupt_moderation = config_param->ParameterData.IntegerData; } NdisReadNetworkAddress(&status, &network_address, &network_address_length, config_handle); if (!NT_SUCCESS(status) || network_address_length != ETH_ALEN || ((((PUCHAR)network_address)[0] & 0x03) != 0x02)) { KdPrint(("Could not read NetworkAddress value (%08x) or value is invalid\n", status)); memset(xi->curr_mac_addr, 0, ETH_ALEN); } else { memcpy(xi->curr_mac_addr, network_address, ETH_ALEN); KdPrint((" Set MAC address from registry to %02X:%02X:%02X:%02X:%02X:%02X\n", xi->curr_mac_addr[0], xi->curr_mac_addr[1], xi->curr_mac_addr[2], xi->curr_mac_addr[3], xi->curr_mac_addr[4], xi->curr_mac_addr[5])); } xi->config_max_pkt_size = max(xi->config_mtu + XN_HDR_SIZE, xi->config_gso + XN_HDR_SIZE); NdisCloseConfiguration(config_handle); status = XenNet_D0Entry(xi); if (!NT_SUCCESS(status)) { KdPrint(("Failed to go to D0 (%08x)\n", status)); goto err; } return NDIS_STATUS_SUCCESS; err: NdisFreeMemory(xi, 0, 0); *OpenErrorStatus = status; FUNCTION_EXIT_STATUS(status); return status; }
NDIS_STATUS MiniportInitialize5( OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext ) { UINT i; PADAPTER pAdapt; NDIS_STATUS Status = NDIS_STATUS_FAILURE; NDIS_MEDIUM Medium; UNREFERENCED_PARAMETER(WrapperConfigurationContext); do { pAdapt = NdisIMGetDeviceContext(MiniportAdapterHandle); pAdapt->MiniportHandle = MiniportAdapterHandle; Medium = pAdapt->Medium; if (Medium == NdisMediumWan) { Medium = NdisMedium802_3; pAdapt->bWanAdapter = TRUE; } for (i = 0; i < MediumArraySize; i++) { if (MediumArray[i] == Medium) { *SelectedMediumIndex = i; break; } } if (i == MediumArraySize) { Status = NDIS_STATUS_UNSUPPORTED_MEDIA; break; } NdisMSetAttributesEx(MiniportAdapterHandle, pAdapt, 0, // CheckForHangTimeInSeconds NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT | NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT| NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER | NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND, 0); pAdapt->LastIndicatedStatus = NDIS_STATUS_MEDIA_CONNECT; pAdapt->MiniportDeviceState = NdisDeviceStateD0; // // Create an ioctl interface // (VOID)ProtocolRegisterDevice(); Status = NDIS_STATUS_SUCCESS; } while (FALSE); ASSERT(pAdapt->MiniportInitPending == TRUE); pAdapt->MiniportInitPending = FALSE; NdisSetEvent(&pAdapt->MiniportInitEvent); *OpenErrorStatus = Status; return Status; }
// Initialization handler of adapter NDIS_STATUS NeoNdisInit(NDIS_STATUS *OpenErrorStatus, UINT *SelectedMediumIndex, NDIS_MEDIUM *MediumArray, UINT MediumArraySize, NDIS_HANDLE MiniportAdapterHandle, NDIS_HANDLE WrapperConfigurationContext) { BOOL media_check; UINT i; if (ctx == NULL) { return NDIS_STATUS_FAILURE; } if (ctx->NdisWrapper == NULL) { ctx->NdisWrapper = ndis_wrapper_handle; } // Prevention of multiple start if (ctx->Initing != FALSE) { // Multiple started return NDIS_STATUS_FAILURE; } ctx->Initing = TRUE; // Examine whether it has already been initialized if (ctx->Inited != FALSE) { // Driver is started on another instance already. // PacketiX VPN driver can start only one instance per one service. // User can start multiple drivers with different instance ID return NDIS_STATUS_FAILURE; } // Current value of the packet filter ctx->CurrentPacketFilter = NDIS_PACKET_TYPE_ALL_LOCAL | NDIS_PACKET_TYPE_BROADCAST | NDIS_PACKET_TYPE_DIRECTED | NDIS_PACKET_TYPE_ALL_FUNCTIONAL; // Examine whether the Ethernet is available media_check = FALSE; for (i = 0;i < MediumArraySize;i++) { if (MediumArray[i] == NEO_MEDIA) { media_check = TRUE; break; } } if (media_check == FALSE) { // Ethernet is unavailable ctx->Initing = FALSE; return NDIS_STATUS_FAILURE; } // Media number to use *SelectedMediumIndex = i; // Initialize the adapter information ctx->NdisMiniport = MiniportAdapterHandle; ctx->NdisConfig = WrapperConfigurationContext; ctx->NdisContext = ctx; ctx->HardwareStatus = NdisHardwareStatusReady; ctx->Halting = FALSE; ctx->Connected = ctx->ConnectedOld = FALSE; if (keep_link == false) { ctx->ConnectedForce = TRUE; } // Read the information from the registry if (NeoLoadRegistory() == FALSE) { // Failure ctx->Initing = FALSE; return NDIS_STATUS_FAILURE; } // Register the device attributes if (g_is_win8 == false) { NdisMSetAttributes(ctx->NdisMiniport, ctx->NdisContext, FALSE, NdisInterfaceInternal); } else { NdisMSetAttributesEx(ctx->NdisMiniport, ctx->NdisContext, 16, NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT | NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT | NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND, NdisInterfaceInternal); } // Initialize the received packet array NeoInitPacketArray(); // Initialize the control device NeoInitControlDevice(); // Start the adapter NeoStartAdapter(); // Flag setting ctx->Initing = FALSE; ctx->Inited = TRUE; // Notify the connection state NeoSetConnectState(FALSE); return NDIS_STATUS_SUCCESS; }
NDIS_STATUS MPInitialize( 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 = NDIS_STATUS_SUCCESS; PHWT_ADAPTER Adapter=NULL; UINT index; DEBUGP(MP_TRACE, ("[HT_STARTUP]---> MPInitialize\n")); PAGED_CODE(); do { for(index = 0; index < MediumArraySize; ++index) { if(MediumArray[index] == NIC_MEDIA_TYPE) { break; } } if(index == MediumArraySize) { DEBUGP(MP_ERROR, ("[HT_STARTUP] Expected media is not in MediumArray.\n")); Status = NDIS_STATUS_UNSUPPORTED_MEDIA; break; } *SelectedMediumIndex = index; DEBUGP(MP_INFO, ("[HT_STARTUP] Expected media is in MediumArray[%d].\n", index)); Status = MpAllocateAdapter(MiniportAdapterHandle, &Adapter); if(Status != NDIS_STATUS_SUCCESS) { break; } Status = NICInitializeAdapter(Adapter, WrapperConfigurationContext); if(Status != NDIS_STATUS_SUCCESS) { Status = NDIS_STATUS_FAILURE; MpFreeAdapter(Adapter); break; } NdisMGetDeviceProperty(MiniportAdapterHandle, &Adapter->Pdo, &Adapter->Fdo, &Adapter->NextDeviceObject, NULL, NULL); NdisMSetAttributesEx( MiniportAdapterHandle, (NDIS_HANDLE) Adapter, 0, #ifdef NDIS50_MINIPORT NDIS_ATTRIBUTE_DESERIALIZE| NDIS_ATTRIBUTE_USES_SAFE_BUFFER_APIS | NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND, #else NDIS_ATTRIBUTE_DESERIALIZE | NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND, #endif NIC_INTERFACE_TYPE); }while(FALSE); if(Status == NDIS_STATUS_SUCCESS) { NICAttachAdapter(Adapter); NICRegisterDevice(); } DEBUGP(MP_TRACE, ("[HT_STARTUP]<--- MPInitialize Status = 0x%08x%\n", Status)); return Status; }
/************************************************************************* * SteMiniportinitialize() * * NDIS エントリポイント * ネットワーク I/O 操作のために NIC ドライバがネットワーク I/O 操作を * するために必要なリソースを確保する。 * * 引数: * * OpenErrorStatus OUT PNDIS_STATUS * SelectedMediumIndex OUT PUINT * MediumArray IN PNDIS_MEDIUM * MediumArraySize IN UINT * MiniportAdapterHandle IN NDIS_HANDLE * WrapperConfigurationContext IN NDIS_HANDLE * * 返り値: * * 正常時: NDIS_STATUS_SUCCESS * *************************************************************************/ NDIS_STATUS SteMiniportInitialize( OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext ) { UINT i; NDIS_STATUS Status = NDIS_STATUS_SUCCESS; STE_ADAPTER *Adapter = NULL; BOOLEAN MediaFound = FALSE; DEBUG_PRINT0(3, "SteMiniportInitialize called\n"); *SelectedMediumIndex = 0; for ( i = 0 ; i < MediumArraySize ; i++){ if (MediumArray[i] == NdisMedium802_3){ *SelectedMediumIndex = i; MediaFound = TRUE; break; } } // 途中で break するためだけの Do-While 文 do { if(!MediaFound){ // 上記の for 文で見つけられなかったようだ DEBUG_PRINT0(1, "SteMiniportInitialize: No Media much\n"); Status = NDIS_STATUS_UNSUPPORTED_MEDIA; break; } // // Adapter を確保し、初期化する // if ((Status = SteCreateAdapter(&Adapter)) != NDIS_STATUS_SUCCESS){ DEBUG_PRINT0(1, "SteMiniportInitialize: Can't allocate memory for STE_ADAPTER\n"); Status = NDIS_STATUS_RESOURCES; break; } DEBUG_PRINT1(3, "SteMiniportInitialize: Adapter = 0x%p\n", Adapter); Adapter->MiniportAdapterHandle = MiniportAdapterHandle; // // Registory を読む処理。...省略。 // NdisOpenConfiguration(); // NdisReadConfiguration(); // // NIC のためのハードウェアリソースのリストを得る。...省略。 // NdisMQueryAdapterResources() // // // NDIS に NIC の情報を伝える。 // かならず NdisXxx 関数を呼び出すより前に、以下の NdisMSetAttributesEx // を呼び出さなければならない。 // NdisMSetAttributesEx( MiniportAdapterHandle, //IN NDIS_HANDLE (NDIS_HANDLE) Adapter, //IN NDIS_HANDLE 0, //IN UINT NDIS_ATTRIBUTE_DESERIALIZE, //IN ULONG Deserialized ミニポートドライバ NdisInterfaceInternal //IN NDIS_INTERFACE_TYPE ); // // NDIS 5.0 の場合はかならず SHUTDOWN_HANDLER を登録しなければならない。 // NdisMRegisterAdapterShutdownHandler( MiniportAdapterHandle, // IN NDIS_HANDLE (PVOID) Adapter, // IN PVOID (ADAPTER_SHUTDOWN_HANDLER) SteMiniportShutdown // IN ADAPTER_SHUTDOWN_HANDLER ); // // 仮想 NIC デーモンからの IOCT/ReadFile/WriteFile 用の // デバイスを作成し、Dispatch ルーチンを登録する。 // SteRegisterDevice(Adapter); // // SteRecvTimerFunc() を呼ぶためのタイマーオブジェクトを初期化 // NdisInitializeTimer( &Adapter->RecvTimer, //IN OUT PNDIS_TIMER SteRecvTimerFunc, //IN PNDIS_TIMER_FUNCTION (PVOID)Adapter //IN PVOID ); // // SteResetTimerFunc() を呼ぶためのタイマーオブジェクトを初期化 // NdisInitializeTimer( &Adapter->ResetTimer, //IN OUT PNDIS_TIMER SteResetTimerFunc, //IN PNDIS_TIMER_FUNCTION (PVOID)Adapter //IN PVOID ); } while (FALSE); return(Status); }