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