NDIS_STATUS
MiniportInitialize (
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE MiniportDriverContext,
IN PNDIS_MINIPORT_INIT_PARAMETERS MiniportInitParameters
)
{
PADAPTER adapter = NULL;
NDIS_STATUS ndisStatus;
PCHAR path;
PDEVICE_OBJECT pdo;
PCHAR xenbusPath = NULL;
int i;
UNREFERENCED_PARAMETER(MiniportDriverContext);
UNREFERENCED_PARAMETER(MiniportInitParameters);
TraceVerbose(("====> '%s'.\n", __FUNCTION__));
//
// Wait for xenbus to come up. SMP guests sometimes try and
// initialise xennet and xenvbd in parallel when they come back
// from hibernation, and that causes problems.
//
if (!xenbus_await_initialisation()) {
ndisStatus = NDIS_STATUS_DEVICE_FAILED;
goto exit;
}
//
// 8021P support is disabled by default.
// It can be turned on by specifying the appropriate PV boot option.
//
if (XenPVFeatureEnabled(DEBUG_NIC_8021_P)) {
XennetMacOptions |= NDIS_MAC_OPTION_8021P_PRIORITY;
}
xenbus_write(XBT_NIL, "drivers/xenwnet", XENNET_VERSION);
NdisMGetDeviceProperty(MiniportAdapterHandle,
&pdo,
NULL,
NULL,
NULL,
NULL);
xenbusPath = xenbus_find_frontend(pdo);
if (!xenbusPath) {
ndisStatus = NDIS_STATUS_ADAPTER_NOT_FOUND;
goto exit;
}
TraceNotice(("Found '%s' frontend.\n", xenbusPath));
adapter = XmAllocateZeroedMemory(sizeof(ADAPTER));
if (adapter == NULL) {
ndisStatus = NDIS_STATUS_RESOURCES;
goto exit;
}
path = xenbusPath;
xenbusPath = NULL;
i = 0;
do {
ndisStatus = AdapterInitialize(adapter, MiniportAdapterHandle, path);
if (ndisStatus != NDIS_STATUS_SUCCESS) {
TraceWarning (("Waiting for backend...\n"));
NdisMSleep (1000000); // 1 sec
}
} while ((ndisStatus != NDIS_STATUS_SUCCESS) && (++i < 30));
if (ndisStatus != NDIS_STATUS_SUCCESS) {
goto exit;
}
exit:
if (ndisStatus != NDIS_STATUS_SUCCESS) {
if (adapter) {
XmFreeMemory(adapter->BackendPath);
adapter->BackendPath = NULL;
AdapterDelete(&adapter);
}
if (xenbusPath) {
XmFreeMemory(xenbusPath);
}
}
TraceVerbose(("<==== '%s'.\n", __FUNCTION__));
return ndisStatus;
}
// 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 windowsFindAdapter(IN P_GLUE_INFO_T prGlueInfo, IN NDIS_HANDLE rWrapperConfigurationContext)
{
NDIS_HANDLE rMiniportAdapterHandle;
PDEVICE_EXTENSION prDevExt;
NDIS_STATUS rStatus;
INT i;
UCHAR ucTmp;
SDBUS_INTERFACE_PARAMETERS rInterfaceParameters = { 0 };
DEBUGFUNC("windowsFindAdapter");
DBGLOG1(INIT, TRACE, "\n");
ASSERT(prGlueInfo);
INITLOG(("windowsFindAdapter\n"));
rMiniportAdapterHandle = prGlueInfo->rMiniportAdapterHandle;
prDevExt = &prGlueInfo->rHifInfo.dx;
NdisMGetDeviceProperty(rMiniportAdapterHandle,
&prDevExt->PhysicalDeviceObject,
&prDevExt->FunctionalDeviceObject, &prDevExt->NextLowerDriverObject, NULL, NULL);
rStatus = SdBusOpenInterface(prDevExt->PhysicalDeviceObject,
&prDevExt->BusInterface,
sizeof(SDBUS_INTERFACE_STANDARD), SDBUS_INTERFACE_VERSION);
INITLOG(("SdBusOpenInterface: (status=0x%x)\n", rStatus));
INITLOG(("Size: (0x%x)\n", prDevExt->BusInterface.Size));
INITLOG(("Version: (0x%x)\n", prDevExt->BusInterface.Version));
INITLOG(("Context: (0x%x)\n", prDevExt->BusInterface.Context));
INITLOG(("InterfaceReference: (0x%x)\n", prDevExt->BusInterface.InterfaceReference));
INITLOG(("InterfaceDereference: (0x%x)\n", prDevExt->BusInterface.InterfaceDereference));
INITLOG(("InitializeInterface: (0x%x)\n", prDevExt->BusInterface.InitializeInterface));
INITLOG(("AcknowledgeInterrupt: (0x%x)\n", prDevExt->BusInterface.AcknowledgeInterrupt));
if (NT_SUCCESS(rStatus)) {
rInterfaceParameters.Size = sizeof(SDBUS_INTERFACE_PARAMETERS);
rInterfaceParameters.TargetObject = prDevExt->NextLowerDriverObject;
/* INTerrupt callback function */
rInterfaceParameters.DeviceGeneratesInterrupts = TRUE;
rInterfaceParameters.CallbackAtDpcLevel = FALSE; /* passive level for synchronous I/O */
rInterfaceParameters.CallbackRoutine = sdioINTerruptCallback;
rInterfaceParameters.CallbackRoutineContext = prGlueInfo;
rStatus = STATUS_UNSUCCESSFUL;
if (prDevExt->BusInterface.InitializeInterface) {
INITLOG(("pDevExt->BusINTerface.InitializeINTerface exists\n"));
rStatus = (prDevExt->BusInterface.InitializeInterface)
(prDevExt->BusInterface.Context, &rInterfaceParameters);
}
/* dump sdbus parameter */
/* dump sdbus INTerface standard after init */
if (NT_SUCCESS(rStatus)) {
INITLOG(("INTial SD-bus INTerface OK!!\n"));
prDevExt->busInited = TRUE;
} else {
ERRORLOG(("INTial SD-bus INTerface fail,status:%x\n", rStatus));
if (prDevExt->BusInterface.InterfaceDereference) {
(prDevExt->BusInterface.InterfaceDereference) (prDevExt->BusInterface.Context);
RtlZeroMemory(&prDevExt->BusInterface, sizeof(SDBUS_INTERFACE_STANDARD));
}
return rStatus;
}
} else { /* open SD-bus INTerface fail */
ERRORLOG(("open SD-bus INTerface fail, status:%x\n", rStatus));
return rStatus;
}
rStatus = sdioSetupCardFeature(prGlueInfo, prDevExt);
return rStatus;
} /* end of windowsFindAdapter() */
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;
}
