// 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;
}
/******************************************************
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 = NdisInterlockedIncrement(&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
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)
{
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;
}
