ZC v1574 : EDID management feature, bug fixes in UMD and KMD

Signed-off-by: Raman, Sudharsan <sudharsan.raman@intel.com>

Author: sraman4

DVInstaller.ps1

@@ -36,9 +36,9 @@ WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll=1 ; make sure the number matches with
 ;*****************************************
 
 [Manufacturer]
-%ManufacturerName%=Standard,NT$ARCH$
+%ManufacturerName%=Standard,NTamd64.10.0...15063
 
-[Standard.NT$ARCH$]
+[Standard.NTamd64.10.0...15063]
 %DVServerKMD.DeviceDesc%=DVServerKMD_Device, PCI\VEN_1AF4&DEV_1050&CC_030000
 
 [DVServerKMD_Device.NT]

DVServerKMD/DVServerKMD.inf

@@ -195,17 +195,7 @@ NTSTATUS DVServerKMDEvtPrepareHardware(
 	//  The following display info will be passed down from DVServerUMD
 	//  For now, just use hard coded one
 	//
-	DXGK_DISPLAY_INFORMATION DisplayInfo = {
-		1024,
-		768,
-		4096,
-		D3DDDIFMT_X8R8G8B8,
-		0,
-		0,
-		0
-	};
-
-	status = pVioGpuAdapterLite->HWInit(ResourcesTranslated, &DisplayInfo);
+	status = pVioGpuAdapterLite->HWInit(ResourcesTranslated, &pVioGpuAdapterLite->DisplayInfo);
 
 	return status;
 }
@@ -257,7 +247,9 @@ NTSTATUS DVServerKMDEvtD0Entry(
 		restarted, and when it has been powered off.
 
 		Note that interrupts will not be enabled at the time that this is called.
-		They will be enabled after this callback completes.
+		They will be enabled after this callback completes. Added a new callback 
+		DVServerKMDEvtDeviceD0EntryPostInterruptsEnabled, which will ensure 
+		successful enablement of interrupts for subsequent actions.
 
 		This function is not marked pageable because this function is in the
 		device power up path. When a function is marked pagable and the code
@@ -281,24 +273,10 @@ NTSTATUS DVServerKMDEvtD0Entry(
 
 	--*/
 {
-	NTSTATUS status = STATUS_SUCCESS;
-	PDEVICE_CONTEXT pDeviceContext;
-	VioGpuAdapterLite* pVioGpuAdapterLite;
 	TRACING();
+	NTSTATUS status = STATUS_SUCCESS;
 	UNREFERENCED_PARAMETER(PreviousState);
-
-	pDeviceContext = DeviceGetContext(Device);
-
-	//
-	// Retrieve the DVServerKMD device instance
-	//
-	pVioGpuAdapterLite = (VioGpuAdapterLite*)pDeviceContext->pvDeviceExtension;
-
-	if (!pVioGpuAdapterLite)
-		return STATUS_UNSUCCESSFUL;
-
-	status = pVioGpuAdapterLite->SetPowerState(PowerDeviceD0);
-
+	UNREFERENCED_PARAMETER(Device);
 	return status;
 }
 
@@ -479,6 +457,50 @@ Return Value:
 	return STATUS_SUCCESS;
 }
 
+NTSTATUS
+DVServerKMDEvtDeviceD0EntryPostInterruptsEnabled(
+	IN WDFDEVICE Device,
+	IN WDF_POWER_DEVICE_STATE PreviousState
+)
+/*++
+
+Routine Description:
+
+	DVServerKMDEvtDeviceD0EntryPostInterruptsEnabled is called by the framework after the
+	driver has enabled the device's hardware interrupts.
+
+Arguments:
+
+	Device - Handle to a framework device object.
+
+	PreviousState - A WDF_POWER_DEVICE_STATE-typed enumerator that identifies the
+				  previous device power state.
+
+Return Value:
+
+	NTSTATUS - Failures will be logged, but not acted on.
+
+--*/
+{
+	TRACING();
+	UNREFERENCED_PARAMETER(PreviousState);
+	NTSTATUS status = STATUS_SUCCESS;
+
+	PDEVICE_CONTEXT pDeviceContext;
+	VioGpuAdapterLite* pVioGpuAdapterLite;
+	pDeviceContext = DeviceGetContext(Device);
+	//
+	// Retrieve the DVServerKMD device instance
+	//
+	pVioGpuAdapterLite = (VioGpuAdapterLite*)pDeviceContext->pvDeviceExtension;
+
+	if (!pVioGpuAdapterLite)
+		return STATUS_UNSUCCESSFUL;
+	status = pVioGpuAdapterLite->SetPowerState(PowerDeviceD0);
+
+	return status;
+}
+
 NTSTATUS DVServerKMDEvtInterruptEnable(
 	IN WDFINTERRUPT  Interrupt,
 	IN WDFDEVICE     AssociatedDevice

DVServerKMD/Device.cpp

@@ -55,6 +55,7 @@ EVT_WDF_DEVICE_D0_EXIT DVServerKMDEvtD0Exit;
 EVT_WDF_INTERRUPT_ISR DVServerKMDEvtInterruptISR;
 EVT_WDF_INTERRUPT_DPC DVServerKMDEvtInterruptDPC;
 EVT_WDF_DEVICE_D0_EXIT_PRE_INTERRUPTS_DISABLED DVServerKMDEvtDeviceD0ExitPreInterruptsDisabled;
+EVT_WDF_DEVICE_D0_ENTRY_POST_INTERRUPTS_ENABLED DVServerKMDEvtDeviceD0EntryPostInterruptsEnabled;
 EVT_WDF_INTERRUPT_ENABLE DVServerKMDEvtInterruptEnable;
 EVT_WDF_INTERRUPT_DISABLE DVServerKMDEvtInterruptDisable;
 EXTERN_C_END

DVServerKMD/Device.h

@@ -189,6 +189,7 @@ Return Value:
 	pnpPowerCallbacks.EvtDeviceD0Exit = DVServerKMDEvtD0Exit;
 
 	pnpPowerCallbacks.EvtDeviceD0ExitPreInterruptsDisabled = DVServerKMDEvtDeviceD0ExitPreInterruptsDisabled;
+	pnpPowerCallbacks.EvtDeviceD0EntryPostInterruptsEnabled = DVServerKMDEvtDeviceD0EntryPostInterruptsEnabled;
 
 	//
 	// Register the PnP Callbacks..

DVServerKMD/Driver.cpp

@@ -160,6 +160,9 @@ NTSTATUS VioGpuAdapterLite::SetCurrentModeExt(CURRENT_MODE* pCurrentMode)
 		return status;
 	}
 
+	// Adding a lock here to prevent potential memory dereferencing issues,
+	//as m_screen is utilized across multiple threads
+	KeWaitForMutexObject(&m_screen_mutex, Executive, KernelMode, FALSE, NULL);
 	DBGPRINT("ScreenNum = %d, Mode = %dx%d\n", pCurrentMode->DispInfo.TargetId, pCurrentMode->DispInfo.Width, pCurrentMode->DispInfo.Height);
 
 	for (ULONG idx = 0; idx < m_screen[pCurrentMode->DispInfo.TargetId].GetModeCount(); idx++)
@@ -183,6 +186,7 @@ NTSTATUS VioGpuAdapterLite::SetCurrentModeExt(CURRENT_MODE* pCurrentMode)
 		break;
 	}
 
+	KeReleaseMutex(&m_screen_mutex, FALSE);
 	return status;
 }
 
@@ -198,6 +202,9 @@ NTSTATUS VioGpuAdapterLite::VioGpuAdapterLiteInit()
 		VioGpuDbgBreak();
 		return status;
 	}
+
+	KeInitializeMutex(&m_screen_mutex, 0);
+
 	status = VirtIoDeviceInit();
 	if (!NT_SUCCESS(status)) {
 		DBGPRINT("Failed to initialize virtio device, error %x\n", status);
@@ -380,7 +387,20 @@ PBYTE VioGpuAdapterLite::GetEdidData(UINT Id)
 {
 	PAGED_CODE();
 	TRACING();
-	return m_bEDID ? m_screen[Id].m_EDIDs : (PBYTE)(&g_gpu_edid);//.data;
+	PBYTE ret;
+
+	if (m_bEDID) {
+		// Adding a lock here to prevent potential memory dereferencing issues,
+		//as m_screen is utilized across multiple threads
+		KeWaitForMutexObject(&m_screen_mutex, Executive, KernelMode, FALSE, NULL);
+		ret = m_screen[Id].m_EDIDs;
+		KeReleaseMutex(&m_screen_mutex, FALSE);
+	}
+	else {
+		ret = (PBYTE)(&g_gpu_edid);
+	}
+
+	return ret;
 }
 
 NTSTATUS VioGpuAdapterLite::HWInit(WDFCMRESLIST pResList, DXGK_DISPLAY_INFORMATION* pDispInfo)
@@ -787,10 +807,14 @@ BOOLEAN VioGpuAdapterLite::GetEdids(UINT32 screen_num)
 
 	PGPU_VBUFFER vbuf = NULL;
 
+	// Adding a lock here to prevent potential memory dereferencing issues,
+	//as m_screen is utilized across multiple threads
+	KeWaitForMutexObject(&m_screen_mutex, Executive, KernelMode, FALSE, NULL);
 	if (m_CtrlQueue.AskEdidInfo(&vbuf, screen_num, &m_screen[screen_num].m_EdidEvent) &&
 		m_CtrlQueue.GetEdidInfo(vbuf, screen_num, m_screen[screen_num].m_EDIDs)) {
 		m_bEDID = TRUE;
 	}
+	KeReleaseMutex(&m_screen_mutex, FALSE);
 	m_CtrlQueue.ReleaseBuffer(vbuf);
 
 	return TRUE;
@@ -881,6 +905,9 @@ NTSTATUS VioGpuAdapterLite::GetModeList(DXGK_DISPLAY_INFORMATION* pDispInfo)
 
 	TRACING();
 
+	// Adding a lock here to prevent potential memory dereferencing issues,
+	//as m_screen is utilized across multiple threads
+	KeWaitForMutexObject(&m_screen_mutex, Executive, KernelMode, FALSE, NULL);
 	for (UINT32 i = 0; i < m_u32NumScanouts; i++) {
 
 		UINT ModeCount = 0;
@@ -971,6 +998,7 @@ NTSTATUS VioGpuAdapterLite::GetModeList(DXGK_DISPLAY_INFORMATION* pDispInfo)
 				m_screen[i].m_ModeInfo[idx].VisScreenHeight);
 		}
 	}
+	KeReleaseMutex(&m_screen_mutex, FALSE);
 	return Status;
 }
 PAGED_CODE_SEG_END
@@ -1060,12 +1088,15 @@ void VioGpuAdapterLite::ThreadWorkRoutine(void)
 void VioGpuAdapterLite::ConfigChanged(void)
 {
 	TRACING();
+	NTSTATUS status = STATUS_SUCCESS;
 	UINT32 events_read, events_clear = 0;
 	virtio_get_config(&m_VioDev, FIELD_OFFSET(GPU_CONFIG, events_read),
 		&events_read, sizeof(m_u32NumScanouts));
 	if (events_read & VIRTIO_GPU_EVENT_DISPLAY) {
-		for (UINT32 i = 0; i < m_u32NumScanouts; i++) {
-			GetDisplayInfo(i);
+		status = GetModeList(&DisplayInfo);
+		if (!NT_SUCCESS(status)) {
+			ERR("GetModeList failed with %x\n", status);
+			VioGpuDbgBreak();
 		}
 		if (hpd_event) {
 			DBGPRINT("Sending Hot Plug event to UMD\n");
@@ -1074,10 +1105,6 @@ void VioGpuAdapterLite::ConfigChanged(void)
 		events_clear |= VIRTIO_GPU_EVENT_DISPLAY;
 		virtio_set_config(&m_VioDev, FIELD_OFFSET(GPU_CONFIG, events_clear),
 			&events_clear, sizeof(m_u32NumScanouts));
-		//        UpdateChildStatus(FALSE);
-		//        ProcessEdid();
-		// TODO: Enable following if needed
-		//UpdateChildStatus(TRUE);
 	}
 }
 

DVServerKMD/viogpulite.cpp

@@ -127,12 +127,22 @@ class IVioGpuAdapterLite {
 	PVOID GetVioGpu(void) { return m_pvDeviceContext; }
 	virtual PBYTE GetEdidData(UINT Idx) = 0;
 	virtual PHYSICAL_ADDRESS GetFrameBufferPA(void) = 0;
+	DXGK_DISPLAY_INFORMATION DisplayInfo = {
+	1024,
+	768,
+	4096,
+	D3DDDIFMT_X8R8G8B8,
+	0,
+	0,
+	0
+	};
 protected:
 	virtual NTSTATUS GetModeList(DXGK_DISPLAY_INFORMATION* pDispInfo) = 0;
 protected:
 	ULONG  m_Id;
 	ScreenInfo m_screen[MAX_SCAN_OUT];
 	BOOLEAN m_bEDID;
+	KMUTEX m_screen_mutex;
 public:
 	PVOID m_pvDeviceContext;
 };
@@ -193,8 +203,6 @@ class VioGpuAdapterLite :
 	void ProcessEdid(UINT32 screen_num);
 	BOOLEAN GetEdids(UINT32 screen_num);
 	void AddEdidModes(UINT32 screen_num);
-	// Not needed by the DVServerKMD
-	//NTSTATUS UpdateChildStatus(BOOLEAN connect);
 	void CreateFrameBufferObj(PVIDEO_MODE_INFORMATION pModeInfo, CURRENT_MODE* pCurrentMode);
 	void DestroyFrameBufferObj(UINT32 screen_num, BOOLEAN bReset);
 	BOOLEAN CreateCursor(_In_ CONST DXGKARG_SETPOINTERSHAPE* pSetPointerShape, _In_ CONST CURRENT_MODE* pCurrentMode);

DVServerKMD/viogpulite.h

@@ -13,6 +13,8 @@
 #include "Trace.h"
 #include "DVEnabler.tmh"
 #include <Windows.h>
+#include <stdio.h>
+#include <string.h>
 
 
 int dvenabler_init()
@@ -67,6 +69,11 @@ int dvenabler_init()
 
 	while (1)
 	{
+		if (IsSystemLocked()) {
+			DBGPRINT("System is in locked state, so wait untill system gets unlocked");
+			continue;
+		}
+
 		//Reset the flags before doing QDC
 		path_count = NULL, mode_count = NULL;
 		found_id_path = FALSE, found_non_id_path = FALSE;
@@ -220,4 +227,58 @@ int GetDisplayCount(disp_info* pdinfo) {
 
 	return DVENABLER_SUCCESS;
 
+}
+
+
+/*******************************************************************************
+*
+* Description
+*
+* IsSystemLocked - This function is used to check if the system is in locked
+* or unlocked state.
+*
+* Parameters
+* Null
+*
+* Return val
+* int - 0 = Unlocked, -1 = ERROR, 1 = Locked
+*
+******************************************************************************/
+
+int IsSystemLocked() {
+	FILE* fp;
+	char buffer[128];
+	int status = TRUE;
+
+	// Run the PowerShell command to get the system lock status
+	fp = _popen("powershell.exe -WindowStyle Hidden -Command \"(quser 2>$null) -and (get-process logonui -ea 0)\"", "r");
+	if (fp == NULL) {
+		ERR("Failed to run PowerShell command.\n");
+		return DVENABLER_FAILURE;
+	}
+
+	// Read the output of the PowerShell command
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		// Check if the output is "true" (indicating locked) and act accordingly
+		if (strstr(buffer, "True") != NULL) {
+			DBGPRINT("System is locked\n");
+			status = TRUE;
+		}
+		else if (strstr(buffer, "False") != NULL) {
+			DBGPRINT("System is unlocked\n");
+			status = FALSE;
+		}
+		else {
+			ERR("Unexpected output\n");
+			status = DVENABLER_FAILURE;
+		}
+	}
+
+	// Close the pipe and print any errors
+	if (_pclose(fp) != 0) {
+		ERR("Error occurred while running PowerShell command.\n");
+		return DVENABLER_FAILURE;
+	}
+
+	return status;
 }

DVServerUMD/DVEnabler/DVEnabler.cpp

@@ -25,4 +25,5 @@ struct disp_info {
 	HANDLE mutex;
 };
 int GetDisplayCount(disp_info* pdinfo);
+int IsSystemLocked();
 #endif //PCH_H

DVServerUMD/DVEnabler/pch.h

@@ -37,7 +37,6 @@
   <ItemGroup>
     <ClCompile Include="Driver.cpp" />
     <ClCompile Include="DVServeredid.cpp" />
-    <ClCompile Include="DVServerregistry.cpp" />
     <ClCompile Include="Tracing.cpp" />
   </ItemGroup>
   <ItemGroup>
@@ -361,4 +360,4 @@ certmgr -del -c -n "DVServer" -s PrivateCertStore</Command>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>