NTSTATUS
VIOSerialEvtDeviceD0EntryPostInterruptsEnabled(
IN WDFDEVICE WdfDevice,
IN WDF_POWER_DEVICE_STATE PreviousState
)
{
PPORTS_DEVICE pContext = GetPortsDevice(WdfDevice);
UNREFERENCED_PARAMETER(PreviousState);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "--> %s\n", __FUNCTION__);
PAGED_CODE();
if(!pContext->DeviceOK)
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "Sending VIRTIO_CONSOLE_DEVICE_READY 0\n");
VIOSerialSendCtrlMsg(WdfDevice, VIRTIO_CONSOLE_BAD_ID, VIRTIO_CONSOLE_DEVICE_READY, 0);
}
else
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "Setting VIRTIO_CONFIG_S_DRIVER_OK flag\n");
VirtIODeviceAddStatus(pContext->pIODevice, VIRTIO_CONFIG_S_DRIVER_OK);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "Sending VIRTIO_CONSOLE_DEVICE_READY 1\n");
VIOSerialSendCtrlMsg(WdfDevice, VIRTIO_CONSOLE_BAD_ID, VIRTIO_CONSOLE_DEVICE_READY, 1);
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "<-- %s\n", __FUNCTION__);
return STATUS_SUCCESS;
}
VOID
VIOSerialPortClose(
IN WDFFILEOBJECT FileObject
)
{
PRAWPDO_VIOSERIAL_PORT pdoData = RawPdoSerialPortGetData(
WdfFileObjectGetDevice(FileObject));
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"--> %s\n", __FUNCTION__);
if (!pdoData->port->Removed && pdoData->port->GuestConnected)
{
VIOSerialSendCtrlMsg(pdoData->port->BusDevice, pdoData->port->PortId,
VIRTIO_CONSOLE_PORT_OPEN, 0);
}
pdoData->port->GuestConnected = FALSE;
WdfSpinLockAcquire(pdoData->port->InBufLock);
VIOSerialDiscardPortDataLocked(pdoData->port);
WdfSpinLockRelease(pdoData->port->InBufLock);
WdfSpinLockAcquire(pdoData->port->OutVqLock);
VIOSerialReclaimConsumedBuffers(pdoData->port);
WdfSpinLockRelease(pdoData->port->OutVqLock);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"<-- %s\n", __FUNCTION__);
}
NTSTATUS
VIOSerialPortEvtDeviceD0ExitPreInterruptsDisabled(
IN WDFDEVICE Device,
IN WDF_POWER_DEVICE_STATE TargetState
)
{
PVIOSERIAL_PORT Port = RawPdoSerialPortGetData(Device)->port;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
PAGED_CODE();
if (Port->GuestConnected && !Port->Removed)
{
VIOSerialSendCtrlMsg(Port->BusDevice, Port->PortId,
VIRTIO_CONSOLE_PORT_OPEN, 0);
Port->GuestConnected = FALSE;
}
Port->Removed = (TargetState >= WdfPowerDeviceD3);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return STATUS_SUCCESS;
}
NTSTATUS VIOSerialPortEvtDeviceD0Entry(
IN WDFDEVICE Device,
IN WDF_POWER_DEVICE_STATE PreviousState)
{
PVIOSERIAL_PORT port = RawPdoSerialPortGetData(Device)->port;
PPORTS_DEVICE pCtx = GetPortsDevice(port->BusDevice);
NTSTATUS status;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
PAGED_CODE();
if ((pCtx->in_vqs == NULL) || (pCtx->in_vqs[port->PortId] == NULL))
{
return STATUS_NOT_FOUND;
}
status = VIOSerialFillQueue(GetInQueue(port), port->InBufLock);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"Error allocating input queue's buffers.\n");
return status;
}
VIOSerialSendCtrlMsg(port->BusDevice, port->PortId,
VIRTIO_CONSOLE_PORT_READY, 1);
if (port->GuestConnected)
{
VIOSerialSendCtrlMsg(port->BusDevice, port->PortId,
VIRTIO_CONSOLE_PORT_OPEN, 1);
}
port->Removed = FALSE;
VIOSerialEnableInterruptQueue(GetInQueue(port));
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
return status;
}
VOID
VIOSerialInitPortConsole(
IN PVIOSERIAL_PORT port
)
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
port->GuestConnected = TRUE;
VIOSerialSendCtrlMsg(port->BusDevice, port->PortId, VIRTIO_CONSOLE_PORT_OPEN, 1);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,"<-- %s\n", __FUNCTION__);
}
VOID
VIOSerialPortCreate(
IN WDFDEVICE WdfDevice,
IN WDFREQUEST Request,
IN WDFFILEOBJECT FileObject
)
{
PRAWPDO_VIOSERIAL_PORT pdoData = RawPdoSerialPortGetData(WdfDevice);
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(FileObject);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"%s Port id = %d\n", __FUNCTION__, pdoData->port->PortId);
if (pdoData->port->Removed)
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"Connect request on removed port id %d\n", pdoData->port->PortId);
status = STATUS_OBJECT_NO_LONGER_EXISTS;
}
else if (pdoData->port->GuestConnected == TRUE)
{
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"Guest already connected to port id %d\n", pdoData->port->PortId);
status = STATUS_OBJECT_NAME_EXISTS;
}
else
{
pdoData->port->GuestConnected = TRUE;
WdfSpinLockAcquire(pdoData->port->OutVqLock);
VIOSerialReclaimConsumedBuffers(pdoData->port);
WdfSpinLockRelease(pdoData->port->OutVqLock);
VIOSerialSendCtrlMsg(pdoData->port->BusDevice, pdoData->port->PortId,
VIRTIO_CONSOLE_PORT_OPEN, 1);
}
WdfRequestComplete(Request, status);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"<-- %s\n", __FUNCTION__);
}
NTSTATUS
VIOSerialDeviceListCreatePdo(
IN WDFCHILDLIST DeviceList,
IN PWDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER IdentificationDescription,
IN PWDFDEVICE_INIT ChildInit
)
{
PVIOSERIAL_PORT pport = NULL;
NTSTATUS status = STATUS_SUCCESS;
WDFDEVICE hChild = NULL;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_PNPPOWER_EVENT_CALLBACKS PnpPowerCallbacks;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_DEVICE_STATE deviceState;
WDF_IO_QUEUE_CONFIG queueConfig;
PRAWPDO_VIOSERIAL_PORT rawPdo = NULL;
WDF_FILEOBJECT_CONFIG fileConfig;
DECLARE_CONST_UNICODE_STRING(deviceId, PORT_DEVICE_ID );
DECLARE_CONST_UNICODE_STRING(deviceLocation, L"RedHat VIOSerial Port" );
DECLARE_UNICODE_STRING_SIZE(buffer, DEVICE_DESC_LENGTH);
UNREFERENCED_PARAMETER(DeviceList);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
pport = CONTAINING_RECORD(IdentificationDescription,
VIOSERIAL_PORT,
Header
);
WdfDeviceInitSetDeviceType(ChildInit, FILE_DEVICE_SERIAL_PORT);
WdfDeviceInitSetIoType(ChildInit, WdfDeviceIoDirect);
do
{
WdfDeviceInitSetExclusive(ChildInit, TRUE);
status = WdfPdoInitAssignRawDevice(ChildInit, &GUID_DEVCLASS_PORT_DEVICE);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignRawDevice failed - 0x%x\n", status);
break;
}
status = WdfDeviceInitAssignSDDLString(ChildInit, &SDDL_DEVOBJ_SYS_ALL_ADM_ALL);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfDeviceInitAssignSDDLString failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAssignDeviceID(ChildInit, &deviceId);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignDeviceID failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAddHardwareID(ChildInit, &deviceId);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAddHardwareID failed - 0x%x\n", status);
break;
}
status = RtlUnicodeStringPrintf(
&buffer,
L"%02u",
pport->PortId
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "RtlUnicodeStringPrintf failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAssignInstanceID(ChildInit, &buffer);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignInstanceID failed - 0x%x\n", status);
break;
}
status = RtlUnicodeStringPrintf(
&buffer,
L"vport%up%u",
pport->DeviceId,
pport->PortId
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"RtlUnicodeStringPrintf failed 0x%x\n", status);
break;
}
status = WdfPdoInitAddDeviceText(
ChildInit,
&buffer,
&deviceLocation,
0x409
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfPdoInitAddDeviceText failed 0x%x\n", status);
break;
}
WdfPdoInitSetDefaultLocale(ChildInit, 0x409);
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
VIOSerialPortCreate,
VIOSerialPortClose,
WDF_NO_EVENT_CALLBACK
);
WdfDeviceInitSetFileObjectConfig(
ChildInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES
);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpPowerCallbacks);
PnpPowerCallbacks.EvtDeviceD0Entry = VIOSerialPortEvtDeviceD0Entry;
PnpPowerCallbacks.EvtDeviceD0ExitPreInterruptsDisabled = VIOSerialPortEvtDeviceD0ExitPreInterruptsDisabled;
PnpPowerCallbacks.EvtDeviceD0Exit = VIOSerialPortEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(ChildInit, &PnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, RAWPDO_VIOSERIAL_PORT);
attributes.SynchronizationScope = WdfSynchronizationScopeDevice;
attributes.ExecutionLevel = WdfExecutionLevelPassive;
status = WdfDeviceCreate(
&ChildInit,
&attributes,
&hChild
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed 0x%x\n", status);
break;
}
rawPdo = RawPdoSerialPortGetData(hChild);
rawPdo->port = pport;
pport->Device = hChild;
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoDeviceControl = VIOSerialPortDeviceControl;
status = WdfIoQueueCreate(hChild,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pport->IoctlQueue
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed (IoCtrl Queue): 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->IoctlQueue,
WdfRequestTypeDeviceControl
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (IoCtrl Queue): 0x%x\n", status);
break;
}
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchSequential);
queueConfig.EvtIoRead = VIOSerialPortRead;
queueConfig.EvtIoStop = VIOSerialPortIoStop;
status = WdfIoQueueCreate(hChild,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pport->ReadQueue
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate (Read Queue) failed 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->ReadQueue,
WdfRequestTypeRead
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (Read Queue): 0x%x\n", status);
break;
}
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchSequential);
queueConfig.AllowZeroLengthRequests = WdfFalse;
queueConfig.EvtIoWrite = VIOSerialPortWrite;
status = WdfIoQueueCreate(hChild, &queueConfig,
WDF_NO_OBJECT_ATTRIBUTES, &pport->WriteQueue);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed (Write Queue): 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->WriteQueue,
WdfRequestTypeWrite
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (Write Queue): 0x%x\n", status);
break;
}
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.NoDisplayInUI = WdfTrue;
pnpCaps.Removable = WdfTrue;
pnpCaps.EjectSupported = WdfTrue;
pnpCaps.SurpriseRemovalOK= WdfTrue;
pnpCaps.Address = pport->DeviceId;
pnpCaps.UINumber = pport->PortId;
WdfDeviceSetPnpCapabilities(hChild, &pnpCaps);
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.DontDisplayInUI = WdfTrue;
WdfDeviceSetDeviceState(hChild, &deviceState);
status = WdfDeviceCreateDeviceInterface(
hChild,
&GUID_VIOSERIAL_PORT,
NULL
);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreateDeviceInterface failed 0x%x\n", status);
break;
}
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = hChild;
status = WdfSpinLockCreate(
&attributes,
&pport->InBufLock
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfSpinLockCreate failed 0x%x\n", status);
break;
}
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = hChild;
status = WdfSpinLockCreate(
&attributes,
&pport->OutVqLock
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfSpinLockCreate failed 0x%x\n", status);
break;
}
} while (0);
if (!NT_SUCCESS(status))
{
// We can send this before PDO is PRESENT since the device won't send any response.
VIOSerialSendCtrlMsg(pport->BusDevice, pport->PortId, VIRTIO_CONSOLE_PORT_READY, 0);
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s status 0x%x\n", __FUNCTION__, status);
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
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;
}
