VOID
VIOSerialRemovePort(
IN WDFDEVICE Device,
IN PVIOSERIAL_PORT Port
)
{
WDFCHILDLIST PortList;
NTSTATUS status;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"--> %s DeviceId: %d PortId: %d\n",
__FUNCTION__, Port->DeviceId, Port->PortId);
Port->Removed = TRUE;
PortList = WdfFdoGetDefaultChildList(Device);
status = WdfChildListUpdateChildDescriptionAsMissing(PortList,
&Port->Header);
if (status == STATUS_NO_SUCH_DEVICE)
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"A device which does not exist was specified.\n", status);
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
}
PVIOSERIAL_PORT
VIOSerialFindPortById(
IN WDFDEVICE Device,
IN ULONG id
)
{
NTSTATUS status = STATUS_SUCCESS;
WDFCHILDLIST list;
WDF_CHILD_LIST_ITERATOR iterator;
PRAWPDO_VIOSERIAL_PORT rawPdo = NULL;
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_PNP,"%s port = %d\n", __FUNCTION__, id);
list = WdfFdoGetDefaultChildList(Device);
WDF_CHILD_LIST_ITERATOR_INIT(&iterator,
WdfRetrievePresentChildren );
WdfChildListBeginIteration(list, &iterator);
for (;;)
{
WDF_CHILD_RETRIEVE_INFO childInfo;
VIOSERIAL_PORT port;
WDFDEVICE hChild;
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&port.Header,
sizeof(port)
);
WDF_CHILD_RETRIEVE_INFO_INIT(&childInfo, &port.Header);
status = WdfChildListRetrieveNextDevice(
list,
&iterator,
&hChild,
&childInfo
);
if (!NT_SUCCESS(status) || status == STATUS_NO_MORE_ENTRIES)
{
break;
}
ASSERT(childInfo.Status == WdfChildListRetrieveDeviceSuccess);
rawPdo = RawPdoSerialPortGetData(hChild);
if(rawPdo && rawPdo->port->PortId == id)
{
WdfChildListEndIteration(list, &iterator);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"%s id = %d port = 0x%p\n", __FUNCTION__, id, rawPdo->port);
return rawPdo->port;
}
}
WdfChildListEndIteration(list, &iterator);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_PNP, "<-- %s\n", __FUNCTION__);
return NULL;
}
VOID
VIOSerialAddPort(
IN WDFDEVICE Device,
IN ULONG id
)
{
VIOSERIAL_PORT port;
PPORTS_DEVICE pContext = GetPortsDevice(Device);
NTSTATUS status = STATUS_SUCCESS;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"%s DeviceId = %d :: PortId = %d\n", __FUNCTION__, pContext->DeviceId, id);
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&port.Header,
sizeof(port)
);
port.PortId = id;
port.DeviceId = pContext->DeviceId;
port.NameString.Buffer = NULL;
port.NameString.Length = 0;
port.NameString.MaximumLength = 0;
port.InBuf = NULL;
port.HostConnected = port.GuestConnected = FALSE;
port.OutVqFull = FALSE;
port.Removed = FALSE;
port.BusDevice = Device;
status = WdfChildListAddOrUpdateChildDescriptionAsPresent(
WdfFdoGetDefaultChildList(Device),
&port.Header,
NULL
);
if (status == STATUS_OBJECT_NAME_EXISTS)
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"The description is already present in the list, the serial number is not unique.\n");
return;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"WdfChildListAddOrUpdateChildDescriptionAsPresent = 0x%x.\n", status);
}
NTSTATUS
Bus_EjectDevice(
WDFDEVICE Device,
ULONG SerialNo
)
/*++
Routine Description:
The user application has told us to eject the device from the bus.
In a real situation the driver gets notified by an interrupt when the
user presses the Eject button on the device.
Arguments:
Returns:
STATUS_SUCCESS upon successful removal from the list
STATUS_INVALID_PARAMETER if the ejection was unsuccessful
--*/
{
WDFDEVICE hChild;
NTSTATUS status = STATUS_INVALID_PARAMETER;
WDFCHILDLIST list;
PAGED_CODE ();
list = WdfFdoGetDefaultChildList(Device);
//
// A zero serial number means eject all children
//
if (0 == SerialNo) {
WDF_CHILD_LIST_ITERATOR iterator;
WDF_CHILD_LIST_ITERATOR_INIT( &iterator,
WdfRetrievePresentChildren );
WdfChildListBeginIteration(list, &iterator);
for ( ; ; ) {
WDF_CHILD_RETRIEVE_INFO childInfo;
PDO_IDENTIFICATION_DESCRIPTION description;
BOOLEAN ret;
//
// Init the structures.
//
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(&description.Header, sizeof(description));
WDF_CHILD_RETRIEVE_INFO_INIT(&childInfo, &description.Header);
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&description.Header,
sizeof(description)
);
//
// Get the device identification description
//
status = WdfChildListRetrieveNextDevice(list,
&iterator,
&hChild,
&childInfo);
if (!NT_SUCCESS(status) || status == STATUS_NO_MORE_ENTRIES) {
break;
}
ASSERT(childInfo.Status == WdfChildListRetrieveDeviceSuccess);
//
// Use that description to request an eject.
//
ret = WdfChildListRequestChildEject(list, &description.Header);
if(!ret) {
WDFVERIFY(ret);
}
}
WdfChildListEndIteration(list, &iterator);
if (status == STATUS_NO_MORE_ENTRIES) {
status = STATUS_SUCCESS;
}
}
else {
PDO_IDENTIFICATION_DESCRIPTION description;
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&description.Header,
sizeof(description)
);
description.SerialNo = SerialNo;
if (WdfChildListRequestChildEject(list, &description.Header)) {
status = STATUS_SUCCESS;
}
}
return status;
}
NTSTATUS
Bus_UnPlugDevice(
WDFDEVICE Device,
ULONG SerialNo
)
/*++
Routine Description:
The application has told us a device has departed from the bus.
We therefore need to flag the PDO as no longer present.
Arguments:
Returns:
STATUS_SUCCESS upon successful removal from the list
STATUS_INVALID_PARAMETER if the removal was unsuccessful
--*/
{
NTSTATUS status;
WDFCHILDLIST list;
PAGED_CODE ();
list = WdfFdoGetDefaultChildList(Device);
if (0 == SerialNo) {
//
// Unplug everybody. We do this by starting a scan and then not reporting
// any children upon its completion
//
status = STATUS_SUCCESS;
WdfChildListBeginScan(list);
//
// A call to WdfChildListBeginScan indicates to the framework that the
// driver is about to scan for dynamic children. After this call has
// returned, all previously reported children associated with this will be
// marked as potentially missing. A call to either
// WdfChildListUpdateChildDescriptionAsPresent or
// WdfChildListMarkAllChildDescriptionsPresent will mark all previuosly
// reported missing children as present. If any children currently
// present are not reported present by calling
// WdfChildListUpdateChildDescriptionAsPresent at the time of
// WdfChildListEndScan, they will be reported as missing to the PnP subsystem
// After WdfChildListEndScan call has returned, the framework will
// invalidate the device relations for the FDO associated with the list
// and report the changes
//
WdfChildListEndScan(list);
}
else {
PDO_IDENTIFICATION_DESCRIPTION description;
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&description.Header,
sizeof(description)
);
description.SerialNo = SerialNo;
//
// WdfFdoUpdateChildDescriptionAsMissing indicates to the framework that a
// child device that was previuosly detected is no longe present on the bus.
// This API can be called by itself or after a call to WdfChildListBeginScan.
// After this call has returned, the framework will invalidate the device
// relations for the FDO associated with the list and report the changes.
//
status = WdfChildListUpdateChildDescriptionAsMissing(list,
&description.Header);
if (status == STATUS_NO_SUCH_DEVICE) {
//
// serial number didn't exist. Remap it to a status that user
// application can understand when it gets translated to win32
// error code.
//
status = STATUS_INVALID_PARAMETER;
}
}
return status;
}
NTSTATUS
Bus_PlugInDevice(
_In_ WDFDEVICE Device,
_In_ PWCHAR HardwareIds,
_In_ size_t CchHardwareIds,
_In_ ULONG SerialNo
)
/*++
Routine Description:
The user application has told us that a new device on the bus has arrived.
We therefore create a description structure in stack, fill in information about
the child device and call WdfChildListAddOrUpdateChildDescriptionAsPresent
to add the device.
--*/
{
PDO_IDENTIFICATION_DESCRIPTION description;
NTSTATUS status;
PAGED_CODE ();
//
// Initialize the description with the information about the newly
// plugged in device.
//
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&description.Header,
sizeof(description)
);
description.SerialNo = SerialNo;
description.CchHardwareIds = CchHardwareIds;
description.HardwareIds = HardwareIds;
//
// Call the framework to add this child to the childlist. This call
// will internaly call our DescriptionCompare callback to check
// whether this device is a new device or existing device. If
// it's a new device, the framework will call DescriptionDuplicate to create
// a copy of this description in nonpaged pool.
// The actual creation of the child device will happen when the framework
// receives QUERY_DEVICE_RELATION request from the PNP manager in
// response to InvalidateDeviceRelations call made as part of adding
// a new child.
//
status = WdfChildListAddOrUpdateChildDescriptionAsPresent(
WdfFdoGetDefaultChildList(Device), &description.Header,
NULL); // AddressDescription
if (status == STATUS_OBJECT_NAME_EXISTS) {
//
// The description is already present in the list, the serial number is
// not unique, return error.
//
status = STATUS_INVALID_PARAMETER;
}
return status;
}
VOID
VIOSerialRenewAllPorts(
IN WDFDEVICE Device
)
{
NTSTATUS status = STATUS_SUCCESS;
WDFCHILDLIST list;
WDF_CHILD_LIST_ITERATOR iterator;
PPORTS_DEVICE pContext = GetPortsDevice(Device);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"--> %s\n", __FUNCTION__);
if(pContext->isHostMultiport)
{
VIOSerialFillQueue(pContext->c_ivq, pContext->CVqLock);
}
list = WdfFdoGetDefaultChildList(Device);
WDF_CHILD_LIST_ITERATOR_INIT(&iterator,
WdfRetrievePresentChildren );
WdfChildListBeginIteration(list, &iterator);
for (;;)
{
WDF_CHILD_RETRIEVE_INFO childInfo;
VIOSERIAL_PORT vport;
WDFDEVICE hChild;
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&vport.Header,
sizeof(vport)
);
WDF_CHILD_RETRIEVE_INFO_INIT(&childInfo, &vport.Header);
status = WdfChildListRetrieveNextDevice(
list,
&iterator,
&hChild,
&childInfo
);
if (!NT_SUCCESS(status) || status == STATUS_NO_MORE_ENTRIES)
{
break;
}
ASSERT(childInfo.Status == WdfChildListRetrieveDeviceSuccess);
VIOSerialEnableInterruptQueue(GetInQueue(&vport));
WdfIoQueueStart(vport.ReadQueue);
WdfIoQueueStart(vport.WriteQueue);
WdfIoQueueStart(vport.IoctlQueue);
if(vport.GuestConnected)
{
VIOSerialSendCtrlMsg(vport.BusDevice, vport.PortId, VIRTIO_CONSOLE_PORT_OPEN, 1);
}
}
WdfChildListEndIteration(list, &iterator);
WdfChildListUpdateAllChildDescriptionsAsPresent(list);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"<-- %s\n", __FUNCTION__);
return;
}
NTSTATUS
XenUsb_EvtDriverDeviceAdd(WDFDRIVER driver, PWDFDEVICE_INIT device_init)
{
NTSTATUS status;
WDF_CHILD_LIST_CONFIG child_list_config;
WDFDEVICE device;
PXENUSB_DEVICE_DATA xudd;
//UNICODE_STRING reference;
WDF_OBJECT_ATTRIBUTES device_attributes;
PNP_BUS_INFORMATION pbi;
WDF_PNPPOWER_EVENT_CALLBACKS pnp_power_callbacks;
WDF_DEVICE_POWER_CAPABILITIES power_capabilities;
WDF_IO_QUEUE_CONFIG queue_config;
UCHAR pnp_minor_functions[] = { IRP_MN_QUERY_INTERFACE };
DECLARE_CONST_UNICODE_STRING(symbolicname_name, L"SymbolicName");
WDFSTRING symbolicname_value_wdfstring;
WDFKEY device_key;
UNICODE_STRING symbolicname_value;
UNREFERENCED_PARAMETER(driver);
FUNCTION_ENTER();
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnp_power_callbacks);
pnp_power_callbacks.EvtDeviceD0Entry = XenUsb_EvtDeviceD0Entry;
pnp_power_callbacks.EvtDeviceD0Exit = XenUsb_EvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(device_init, &pnp_power_callbacks);
status = WdfDeviceInitAssignWdmIrpPreprocessCallback(device_init, XenUsb_EvtDeviceWdmIrpPreprocessQUERY_INTERFACE,
IRP_MJ_PNP, pnp_minor_functions, ARRAY_SIZE(pnp_minor_functions));
if (!NT_SUCCESS(status))
{
return status;
}
WdfDeviceInitSetDeviceType(device_init, FILE_DEVICE_BUS_EXTENDER);
WdfDeviceInitSetExclusive(device_init, FALSE);
WDF_CHILD_LIST_CONFIG_INIT(&child_list_config, sizeof(XENUSB_PDO_IDENTIFICATION_DESCRIPTION), XenUsb_EvtChildListCreateDevice);
child_list_config.EvtChildListScanForChildren = XenUsb_EvtChildListScanForChildren;
WdfFdoInitSetDefaultChildListConfig(device_init, &child_list_config, WDF_NO_OBJECT_ATTRIBUTES);
WdfDeviceInitSetIoType(device_init, WdfDeviceIoBuffered);
WdfDeviceInitSetPowerNotPageable(device_init);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&device_attributes, XENUSB_DEVICE_DATA);
status = WdfDeviceCreate(&device_init, &device_attributes, &device);
if (!NT_SUCCESS(status))
{
FUNCTION_MSG("Error creating device %08x\n", status);
return status;
}
xudd = GetXudd(device);
xudd->pdo = WdfDeviceWdmGetPhysicalDevice(device);
xudd->child_list = WdfFdoGetDefaultChildList(device);
KeInitializeEvent(&xudd->backend_event, SynchronizationEvent, FALSE);
InitializeListHead(&xudd->partial_pvurb_queue);
InitializeListHead(&xudd->partial_pvurb_ring);
KeInitializeDpc(&xudd->event_dpc, XenUsb_HandleEventDpc, xudd);
KeInitializeSpinLock(&xudd->urb_ring_lock);
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queue_config, WdfIoQueueDispatchParallel);
queue_config.PowerManaged = FALSE; /* ? */
queue_config.EvtIoDeviceControl = XenUsb_EvtIoDeviceControl;
queue_config.EvtIoInternalDeviceControl = XenUsb_EvtIoInternalDeviceControl;
queue_config.EvtIoDefault = XenUsb_EvtIoDefault;
status = WdfIoQueueCreate(device, &queue_config, WDF_NO_OBJECT_ATTRIBUTES, &xudd->io_queue);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("Error creating io_queue 0x%x\n", status);
return status;
}
WDF_IO_QUEUE_CONFIG_INIT(&queue_config, WdfIoQueueDispatchParallel);
queue_config.PowerManaged = FALSE; /* ? */
//queue_config.EvtIoDeviceControl = XenUsb_EvtIoDeviceControl;
queue_config.EvtIoInternalDeviceControl = XenUsb_EvtIoInternalDeviceControl_PVURB;
//queue_config.EvtIoDefault = XenUsb_EvtIoDefault;
queue_config.Settings.Parallel.NumberOfPresentedRequests = USB_URB_RING_SIZE; /* the queue controls if the ring is full */
status = WdfIoQueueCreate(device, &queue_config, WDF_NO_OBJECT_ATTRIBUTES, &xudd->pvurb_queue);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("Error creating urb_queue 0x%x\n", status);
return status;
}
WDF_DEVICE_POWER_CAPABILITIES_INIT(&power_capabilities);
power_capabilities.DeviceD1 = WdfTrue;
power_capabilities.WakeFromD1 = WdfTrue;
power_capabilities.DeviceWake = PowerDeviceD1;
power_capabilities.DeviceState[PowerSystemWorking] = PowerDeviceD0;
power_capabilities.DeviceState[PowerSystemSleeping1] = PowerDeviceD1;
power_capabilities.DeviceState[PowerSystemSleeping2] = PowerDeviceD2;
power_capabilities.DeviceState[PowerSystemSleeping3] = PowerDeviceD2;
power_capabilities.DeviceState[PowerSystemHibernate] = PowerDeviceD3;
power_capabilities.DeviceState[PowerSystemShutdown] = PowerDeviceD3;
WdfDeviceSetPowerCapabilities(device, &power_capabilities);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFilePaging, TRUE);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFileHibernation, TRUE);
WdfDeviceSetSpecialFileSupport(device, WdfSpecialFileDump, TRUE);
pbi.BusTypeGuid = GUID_BUS_TYPE_XEN;
pbi.LegacyBusType = PNPBus;
pbi.BusNumber = 0;
WdfDeviceSetBusInformationForChildren(device, &pbi);
status = WdfDeviceCreateDeviceInterface(device, &GUID_DEVINTERFACE_USB_HOST_CONTROLLER, NULL);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceCreateDeviceInterface returned %08x\n");
return status;
}
/* USB likes to have a registry key with the symbolic link name in it */
status = WdfStringCreate(NULL, WDF_NO_OBJECT_ATTRIBUTES, &symbolicname_value_wdfstring);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfStringCreate returned %08x\n");
return status;
}
status = WdfDeviceRetrieveDeviceInterfaceString(device, &GUID_DEVINTERFACE_USB_HOST_CONTROLLER, NULL, symbolicname_value_wdfstring);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceRetrieveDeviceInterfaceString returned %08x\n");
return status;
}
WdfStringGetUnicodeString(symbolicname_value_wdfstring, &symbolicname_value);
status = WdfDeviceOpenRegistryKey(device, PLUGPLAY_REGKEY_DEVICE, KEY_SET_VALUE, WDF_NO_OBJECT_ATTRIBUTES, &device_key);
if (!NT_SUCCESS(status)) {
FUNCTION_MSG("WdfDeviceOpenRegistryKey returned %08x\n");
return status;
}
WdfRegistryAssignUnicodeString(device_key, &symbolicname_name, &symbolicname_value);
FUNCTION_EXIT();
return status;
}
VOID
OsrFxEnumerateChildren(
_In_ WDFDEVICE Device
)
/*++
Routine Description:
This routine configures a continuous reader on the
interrupt endpoint.
Arguments:
Return Value:
NT status value
--*/
{
WDFCHILDLIST list;
UCHAR i;
NTSTATUS status;
PDEVICE_CONTEXT pDeviceContext;
pDeviceContext = GetDeviceContext(Device);
list = WdfFdoGetDefaultChildList(Device);
WdfChildListBeginScan(list);
//
// A call to WdfChildListBeginScan indicates to the framework that the
// driver is about to scan for dynamic children. If the driver doesn't
// call either WdfChildListUpdateChildDescriptionAsPresent or
// WdfChildListMarkAllChildDescriptionsPresent before WdfChildListEndScan is,
// called, all the previously reported children will be reported as missing
// to the PnP subsystem.
//
for(i=0; i< RTL_BITS_OF(UCHAR); i++) {
//
// Report every set bit in the switchstate as a child device.
//
if(pDeviceContext->CurrentSwitchState & (1<<i)) {
PDO_IDENTIFICATION_DESCRIPTION description;
//
// Initialize the description with the information about the newly
// plugged in device.
//
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&description.Header,
sizeof(description)
);
//
// Since switches are marked in the wrong order on the board,
// we will fix it here so that the DM display matches with the
// board.
//
description.SwitchNumber = RTL_BITS_OF(UCHAR)-i;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
"Switch %d is ON\n", description.SwitchNumber);
//
// Call the framework to add this child to the devicelist. This call
// will internaly call our DescriptionCompare callback to check
// whether this device is a new device or existing device. If
// it's a new device, the framework will call DescriptionDuplicate to create
// a copy of this description in nonpaged pool.
// The actual creation of the child device will happen when the framework
// receives QUERY_DEVICE_RELATION request from the PNP manager in
// response to InvalidateDevice relation call made as part of adding
// a new child.
//
status = WdfChildListAddOrUpdateChildDescriptionAsPresent(
list,
&description.Header,
NULL); // AddressDescription
if (status == STATUS_OBJECT_NAME_EXISTS) {
}
}
}
WdfChildListEndScan(list);
return;
}
NTSTATUS
VIOSerialEvtDeviceD0ExitPreInterruptsDisabled(
IN WDFDEVICE WdfDevice,
IN WDF_POWER_DEVICE_STATE TargetState
)
{
NTSTATUS status = STATUS_SUCCESS;
WDFCHILDLIST portList;
WDF_CHILD_LIST_ITERATOR portIterator;
UNREFERENCED_PARAMETER(TargetState);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "--> %s\n", __FUNCTION__);
PAGED_CODE();
portList = WdfFdoGetDefaultChildList(WdfDevice);
WDF_CHILD_LIST_ITERATOR_INIT(&portIterator, WdfRetrievePresentChildren);
WdfChildListBeginIteration(portList, &portIterator);
for (;;)
{
WDF_CHILD_RETRIEVE_INFO childInfo;
WDFDEVICE hChild;
VIOSERIAL_PORT port;
PRAWPDO_VIOSERIAL_PORT pdoData;
WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
&port.Header, sizeof(port));
WDF_CHILD_RETRIEVE_INFO_INIT(&childInfo, &port.Header);
status = WdfChildListRetrieveNextDevice(portList, &portIterator,
&hChild, &childInfo);
if (!NT_SUCCESS(status) || (status == STATUS_NO_MORE_ENTRIES))
{
break;
}
ASSERT(childInfo.Status == WdfChildListRetrieveDeviceSuccess);
pdoData = RawPdoSerialPortGetData(hChild);
if (pdoData->port->GuestConnected && !pdoData->port->Removed)
{
VIOSerialSendCtrlMsg(pdoData->port->BusDevice, pdoData->port->PortId,
VIRTIO_CONSOLE_PORT_OPEN, 0);
pdoData->port->GuestConnected = FALSE;
}
pdoData->port->Removed = TRUE;
}
WdfChildListEndIteration(portList, &portIterator);
if (status == STATUS_NO_MORE_ENTRIES)
{
status = STATUS_SUCCESS;
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "<-- %s: 0x%x\n",
__FUNCTION__, status);
return status;
}