sgpc.cpp File Reference

#include "driver.h"

Include dependency graph for sgpc.cpp:

Go to the source code of this file.

Functions
NTSTATUS NTAPI	HDAGraphics_EvtIoTargetQueryRemove (WDFIOTARGET ioTarget)
void NTAPI	HDAGraphics_EvtIoTargetRemoveCanceled (WDFIOTARGET ioTarget)
void NTAPI	HDAGraphics_EvtIoTargetRemoveComplete (WDFIOTARGET ioTarget)
void	HDAGraphicsPowerNotificationCallback (PVOID GraphicsDeviceHandle, DEVICE_POWER_STATE NewGrfxPowerState, BOOLEAN PreNotification, PVOID PrivateHandle)
void	HDAGraphicsPowerRemovalNotificationCallback (PVOID GraphicsDeviceHandle, PVOID PrivateHandle)
void NTAPI	Fdo_EnumerateCodec (PFDO_CONTEXT fdoCtx, UINT8 addr)
void NTAPI	EjectGraphicsCodec (PFDO_CONTEXT fdoCtx)
void NTAPI	EnumerateGraphicsCodec (PFDO_CONTEXT fdoCtx)
void	HDAGraphicsPowerFStateNotificationCallback (PVOID GraphicsDeviceHandle, ULONG ComponentIndex, UINT NewFState, BOOLEAN PreNotification, PVOID PrivateHandle)
void	HDAGraphicsPowerInitialComponentStateCallback (PVOID GraphicsDeviceHandle, PVOID PrivateHandle, ULONG ComponentIndex, BOOLEAN IsBlockingType, UINT InitialFState, GUID ComponentGuid, UINT PowerComponentMappingFlag)
void NTAPI	HDAGraphicsPowerInterfaceAdd (WDFWORKITEM WorkItem)
NTSTATUS NTAPI	HDAGraphicsPowerInterfaceCallback (PVOID NotificationStruct, PVOID Context)
void	CheckHDAGraphicsRegistryKeys (PFDO_CONTEXT fdoCtx)

Function Documentation

CheckHDAGraphicsRegistryKeys()

void CheckHDAGraphicsRegistryKeys

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 313 of file sgpc.cpp.

                                                       {
    NTSTATUS status;
    WDFKEY driverKey;
    status = WdfDeviceOpenRegistryKey(fdoCtx->WdfDevice, PLUGPLAY_REGKEY_DRIVER, READ_CONTROL, NULL, &driverKey);
    if (!NT_SUCCESS(status)) {
        return;
    }
 
    WDFKEY settingsKey;
    DECLARE_CONST_UNICODE_STRING(DriverSettings, L"Settings");
    DECLARE_CONST_UNICODE_STRING(GfxSharedCodecAddress, L"GfxSharedCodecAddress");
    status = WdfRegistryOpenKey(driverKey, &DriverSettings, READ_CONTROL, NULL, &settingsKey);
    if (!NT_SUCCESS(status)) {
        goto closeDriverKey;
    }
 
    ULONG GfxCodecAddr;
    status = WdfRegistryQueryULong(settingsKey, &GfxSharedCodecAddress, &GfxCodecAddr);
    if (NT_SUCCESS(status)) {
        fdoCtx->UseSGPCCodec = TRUE;
        fdoCtx->GraphicsCodecAddress = GfxCodecAddr;
    }
 
    WdfRegistryClose(settingsKey);
 
closeDriverKey:
    WdfRegistryClose(driverKey);
}

Referenced by Fdo_Create().

EjectGraphicsCodec()

void NTAPI EjectGraphicsCodec

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 93 of file sgpc.cpp.

                                        {
    if (!fdoCtx->UseSGPCCodec) {
        return;
    }
 
    if (!fdoCtx->codecs[fdoCtx->GraphicsCodecAddress])
        return;
 
    fdoCtx->GraphicsCodecConnected = FALSE;
    
    PDO_IDENTIFICATION_DESCRIPTION description;//
    // Initialize the description with the information about the detected codec.
    //
    WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
        &description.Header,
        sizeof(description)
    );
 
    description.FdoContext = fdoCtx;
    RtlCopyMemory(&description.CodecIds, &fdoCtx->codecs[fdoCtx->GraphicsCodecAddress]->CodecIds, sizeof(description.CodecIds));
 
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "Ejecting Gfx Codec\n");
 
    WdfInterruptAcquireLock(fdoCtx->Interrupt);
 
    WdfChildListUpdateChildDescriptionAsMissing(WdfFdoGetDefaultChildList(fdoCtx->WdfDevice), &description.Header);
    //Don't null FdoContext to allow SGPC Audio driver to unregister callbacks / events and cleanup
 
    WdfInterruptReleaseLock(fdoCtx->Interrupt);
 
}

Referenced by HDAGraphicsPowerFStateNotificationCallback().

EnumerateGraphicsCodec()

void NTAPI EnumerateGraphicsCodec

(

PFDO_CONTEXT

fdoCtx

)

Definition at line 128 of file sgpc.cpp.

                                            {
    if (!fdoCtx->UseSGPCCodec) {
        return;
    }
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "Enumerating Gfx Codec\n");
    fdoCtx->GraphicsCodecConnected = TRUE;
    Fdo_EnumerateCodec(fdoCtx, (UINT8)fdoCtx->GraphicsCodecAddress);
}

Referenced by HDAGraphicsPowerFStateNotificationCallback(), and HDAGraphicsPowerInitialComponentStateCallback().

Fdo_EnumerateCodec()

void NTAPI Fdo_EnumerateCodec	(	PFDO_CONTEXT	fdoCtx,
		UINT8	addr
	)

Definition at line 680 of file fdo.cpp.

{
    UINT32 cmdTmpl = (addr << 28) | (AC_NODE_ROOT << 20) |
        (AC_VERB_PARAMETERS << 8);
    ULONG funcType = 0, vendorDevice, subsysId, revId, nodeCount;
    if (!NT_SUCCESS(RunSingleHDACmd(fdoCtx, cmdTmpl | AC_PAR_VENDOR_ID, &vendorDevice))) {
        return;
    }
    if (!NT_SUCCESS(RunSingleHDACmd(fdoCtx, cmdTmpl | AC_PAR_REV_ID, &revId))) {
        return;
    }
    if (!NT_SUCCESS(RunSingleHDACmd(fdoCtx, cmdTmpl | AC_PAR_NODE_COUNT, &nodeCount))) {
        return;
    }
 
    fdoCtx->numCodecs += 1;
 
    UINT8 startID = (nodeCount >> 16) & 0xFF;
    nodeCount = (nodeCount & 0x7FFF);
 
    UINT16 mainFuncGrp = 0;
    {
        UINT16 nid = startID;
        for (UINT32 i = 0; i < nodeCount; i++, nid++) {
            UINT32 cmd = (addr << 28) | (nid << 20) |
                (AC_VERB_PARAMETERS << 8) | AC_PAR_FUNCTION_TYPE;
            if (!NT_SUCCESS(RunSingleHDACmd(fdoCtx, cmd, &funcType))) {
                continue;
            }
            switch (funcType & 0xFF) {
            case AC_GRP_AUDIO_FUNCTION:
            case AC_GRP_MODEM_FUNCTION:
                mainFuncGrp = nid;
                break;
            }
        }
    }
 
    UINT32 cmd = (addr << 28) | (mainFuncGrp << 20) |
        (AC_VERB_GET_SUBSYSTEM_ID << 8);
    RunSingleHDACmd(fdoCtx, cmd, &subsysId);
 
    PDO_IDENTIFICATION_DESCRIPTION description;
    //
    // Initialize the description with the information about the detected codec.
    //
    WDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER_INIT(
        &description.Header,
        sizeof(description)
    );
 
    description.FdoContext = fdoCtx;
 
    description.CodecIds.CtlrDevId = fdoCtx->devId;
    description.CodecIds.CtlrVenId = fdoCtx->venId;
 
    description.CodecIds.CodecAddress = addr;
    if (fdoCtx->UseSGPCCodec && addr == fdoCtx->GraphicsCodecAddress)
        description.CodecIds.IsGraphicsCodec = TRUE;
    else
        description.CodecIds.IsGraphicsCodec = FALSE;
 
    description.CodecIds.FunctionGroupStartNode = startID;
 
    description.CodecIds.IsDSP = FALSE;
 
    description.CodecIds.FuncId = funcType & 0xFF;
    description.CodecIds.VenId = (vendorDevice >> 16) & 0xFFFF;
    description.CodecIds.DevId = vendorDevice & 0xFFFF;
    description.CodecIds.SubsysId = subsysId;
    description.CodecIds.RevId = (revId >> 8) & 0xFFFF;
 
    //
    // 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.
    //
    WdfChildListAddOrUpdateChildDescriptionAsPresent(
        WdfFdoGetDefaultChildList(fdoCtx->WdfDevice), &description.Header,
        NULL); // AddressDescription
}

Referenced by EnumerateGraphicsCodec(), and Fdo_EvtDeviceSelfManagedIoInit().

HDAGraphics_EvtIoTargetQueryRemove()

NTSTATUS NTAPI HDAGraphics_EvtIoTargetQueryRemove

(

WDFIOTARGET

ioTarget

)

Definition at line 5 of file sgpc.cpp.

  {
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "Device Removal Notification\n");
 
    WdfIoTargetCloseForQueryRemove(ioTarget);
    return STATUS_SUCCESS;
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphics_EvtIoTargetRemoveCanceled()

void NTAPI HDAGraphics_EvtIoTargetRemoveCanceled

(

WDFIOTARGET

ioTarget

)

Definition at line 17 of file sgpc.cpp.

  {
    WDF_IO_TARGET_OPEN_PARAMS openParams;
    NTSTATUS status;
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "Device Removal Cancel\n");
 
    WDF_IO_TARGET_OPEN_PARAMS_INIT_REOPEN(&openParams);
 
    status = WdfIoTargetOpen(ioTarget, &openParams);
 
    if (!NT_SUCCESS(status)) {
        SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
            "WdfIoTargetOpen failed 0x%x\n", status);
        WdfObjectDelete(ioTarget);
        return;
    }
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphics_EvtIoTargetRemoveComplete()

void NTAPI HDAGraphics_EvtIoTargetRemoveComplete

(

WDFIOTARGET

ioTarget

)

Definition at line 39 of file sgpc.cpp.

  {
    PFDO_CONTEXT fdoCtx;
    SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
        "Device Removal Complete\n");
 
    PGRAPHICSIOTARGET_CONTEXT ioTargetContext;
    ioTargetContext = GraphicsIoTarget_GetContext(ioTarget);
 
    fdoCtx = ioTargetContext->FdoContext;
 
    WdfWaitLockAcquire(fdoCtx->GraphicsDevicesCollectionWaitLock, NULL);
    WdfCollectionRemove(fdoCtx->GraphicsDevicesCollection, ioTarget);
    WdfWaitLockRelease(fdoCtx->GraphicsDevicesCollectionWaitLock);
 
    WdfObjectDelete(ioTarget);
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphicsPowerFStateNotificationCallback()

void HDAGraphicsPowerFStateNotificationCallback	(	PVOID	GraphicsDeviceHandle,
		ULONG	ComponentIndex,
		UINT	NewFState,
		BOOLEAN	PreNotification,
		PVOID	PrivateHandle
	)

Definition at line 138 of file sgpc.cpp.

  {
    PFDO_CONTEXT fdoCtx = (PFDO_CONTEXT)PrivateHandle;
    UNREFERENCED_PARAMETER(GraphicsDeviceHandle);
    UNREFERENCED_PARAMETER(ComponentIndex);
    if (NewFState) {
        if (PreNotification) {
            EjectGraphicsCodec(fdoCtx);
        }
        else {
 
        }
    }
    else {
        if (PreNotification) {
 
        }
        else {
            EnumerateGraphicsCodec(fdoCtx);
        }
    }
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphicsPowerInitialComponentStateCallback()

void HDAGraphicsPowerInitialComponentStateCallback	(	PVOID	GraphicsDeviceHandle,
		PVOID	PrivateHandle,
		ULONG	ComponentIndex,
		BOOLEAN	IsBlockingType,
		UINT	InitialFState,
		GUID	ComponentGuid,
		UINT	PowerComponentMappingFlag
	)

Definition at line 166 of file sgpc.cpp.

  {
    UNREFERENCED_PARAMETER(GraphicsDeviceHandle);
    UNREFERENCED_PARAMETER(ComponentIndex);
    UNREFERENCED_PARAMETER(IsBlockingType);
    UNREFERENCED_PARAMETER(ComponentGuid);
    PFDO_CONTEXT fdoCtx = (PFDO_CONTEXT)PrivateHandle;
    if (PowerComponentMappingFlag) {
    }
    else {
        if (InitialFState) {
        } else {
            EnumerateGraphicsCodec(fdoCtx);
        }
    }
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphicsPowerInterfaceAdd()

void NTAPI HDAGraphicsPowerInterfaceAdd

(

WDFWORKITEM

WorkItem

)

Definition at line 192 of file sgpc.cpp.

                                                   {
    PGRAPHICSWORKITEM_CONTEXT workItemContext = GraphicsWorkitem_GetContext(WorkItem);
    PFDO_CONTEXT fdoCtx = workItemContext->FdoContext;
    PUNICODE_STRING graphicsDeviceSymlink = &workItemContext->GPUDeviceSymlink;
 
    WDF_OBJECT_ATTRIBUTES attributes;
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, GRAPHICSIOTARGET_CONTEXT);
 
    WDFIOTARGET ioTarget;
    WDF_IO_TARGET_OPEN_PARAMS openParams;
    PGRAPHICSIOTARGET_CONTEXT ioTargetContext;
 
    NTSTATUS status = WdfIoTargetCreate(fdoCtx->WdfDevice, &attributes, &ioTarget);
    if (!NT_SUCCESS(status)) {
        SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
            "WdfIoTargetCreate failed 0x%x\n", status);
        goto exit;
    }
 
    ioTargetContext = GraphicsIoTarget_GetContext(ioTarget);
    ioTargetContext->FdoContext = fdoCtx;
 
    WDF_IO_TARGET_OPEN_PARAMS_INIT_OPEN_BY_NAME(
        &openParams,
        graphicsDeviceSymlink,
        STANDARD_RIGHTS_ALL);
    openParams.ShareAccess = FILE_SHARE_WRITE | FILE_SHARE_READ;
    openParams.EvtIoTargetQueryRemove = HDAGraphics_EvtIoTargetQueryRemove;
    openParams.EvtIoTargetRemoveCanceled = HDAGraphics_EvtIoTargetRemoveCanceled;
    openParams.EvtIoTargetRemoveComplete = HDAGraphics_EvtIoTargetRemoveComplete;
 
    status = WdfIoTargetOpen(ioTarget, &openParams);
 
    if (!NT_SUCCESS(status)) {
        SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
            "WdfIoTargetOpen failed with status 0x%x\n", status);
        WdfObjectDelete(ioTarget);
        goto exit;
    }
 
    WdfWaitLockAcquire(fdoCtx->GraphicsDevicesCollectionWaitLock, NULL);
    WdfCollectionAdd(fdoCtx->GraphicsDevicesCollection, ioTarget);
    WdfWaitLockRelease(fdoCtx->GraphicsDevicesCollectionWaitLock);
 
    DXGK_GRAPHICSPOWER_REGISTER_INPUT graphicsPowerRegisterInput;
    graphicsPowerRegisterInput = { 0 };
    graphicsPowerRegisterInput.Version = DXGK_GRAPHICSPOWER_VERSION;
    graphicsPowerRegisterInput.PrivateHandle = fdoCtx;
    graphicsPowerRegisterInput.PowerNotificationCb = HDAGraphicsPowerNotificationCallback;
    graphicsPowerRegisterInput.RemovalNotificationCb = HDAGraphicsPowerRemovalNotificationCallback;
    graphicsPowerRegisterInput.FStateNotificationCb = HDAGraphicsPowerFStateNotificationCallback;
    graphicsPowerRegisterInput.InitialComponentStateCb = HDAGraphicsPowerInitialComponentStateCallback;
 
    WDF_MEMORY_DESCRIPTOR inputDescriptor;
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&inputDescriptor, &graphicsPowerRegisterInput, sizeof(graphicsPowerRegisterInput));
 
    WDF_MEMORY_DESCRIPTOR outputDescriptor;
    WDF_MEMORY_DESCRIPTOR_INIT_BUFFER(&outputDescriptor, &ioTargetContext->graphicsPowerRegisterOutput, sizeof(ioTargetContext->graphicsPowerRegisterOutput));
 
    status = WdfIoTargetSendInternalIoctlSynchronously(ioTarget,
        WDF_NO_HANDLE,
        IOCTL_INTERNAL_GRAPHICSPOWER_REGISTER,
        &inputDescriptor, &outputDescriptor, NULL, NULL);
    if (!NT_SUCCESS(status)) {
        SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
            "IOCTL_INTERNAL_GRAPHICSPOWER_REGISTER failed with status 0x%x\n", status);
        goto exit;
    }
 
exit:
    WdfObjectDelete(WorkItem);
}

Referenced by HDAGraphicsPowerInterfaceCallback().

HDAGraphicsPowerInterfaceCallback()

NTSTATUS NTAPI HDAGraphicsPowerInterfaceCallback	(	PVOID	NotificationStruct,
		PVOID	Context
	)

Definition at line 267 of file sgpc.cpp.

  {
    NTSTATUS status = STATUS_SUCCESS;
    PFDO_CONTEXT fdoCtx = (PFDO_CONTEXT)Context;
    PDEVICE_INTERFACE_CHANGE_NOTIFICATION devNotificationStruct = (PDEVICE_INTERFACE_CHANGE_NOTIFICATION)NotificationStruct;
 
    if (!IsEqualGUID(devNotificationStruct->InterfaceClassGuid, GUID_DEVINTERFACE_GRAPHICSPOWER)) {
        return STATUS_NOT_SUPPORTED;
    }
 
    if (IsEqualGUID(devNotificationStruct->Event, GUID_DEVICE_INTERFACE_ARRIVAL)) {
        SklHdAudBusPrint(DEBUG_LEVEL_INFO, DBG_INIT,
            "Graphics Arrival Notification!\n");
 
        status = RtlUnicodeStringValidate(devNotificationStruct->SymbolicLinkName);
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        WDF_WORKITEM_CONFIG workItemConfig;
        WDF_WORKITEM_CONFIG_INIT(&workItemConfig, HDAGraphicsPowerInterfaceAdd);
 
        WDF_OBJECT_ATTRIBUTES  attributes;
        WDFWORKITEM workItem;
 
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(
            &attributes,
            GRAPHICSWORKITEM_CONTEXT
        );
        attributes.ParentObject = fdoCtx->WdfDevice;
 
        WdfWorkItemCreate(&workItemConfig, &attributes, &workItem);
 
        PGRAPHICSWORKITEM_CONTEXT workItemContext = GraphicsWorkitem_GetContext(workItem);
        workItemContext->FdoContext = fdoCtx;
        workItemContext->GPUDeviceSymlink = *devNotificationStruct->SymbolicLinkName;
 
        WdfWorkItemEnqueue(workItem);
    }
 
    return status;
}

Referenced by Fdo_EvtDeviceSelfManagedIoInit().

HDAGraphicsPowerNotificationCallback()

void HDAGraphicsPowerNotificationCallback	(	PVOID	GraphicsDeviceHandle,
		DEVICE_POWER_STATE	NewGrfxPowerState,
		BOOLEAN	PreNotification,
		PVOID	PrivateHandle
	)

Definition at line 59 of file sgpc.cpp.

  {
    PFDO_CONTEXT fdoCtx = (PFDO_CONTEXT)PrivateHandle;
    UNREFERENCED_PARAMETER(GraphicsDeviceHandle);
    UNREFERENCED_PARAMETER(NewGrfxPowerState);
    UNREFERENCED_PARAMETER(PreNotification);
    UNREFERENCED_PARAMETER(fdoCtx);
    //No-Op
}

Referenced by HDAGraphicsPowerInterfaceAdd().

HDAGraphicsPowerRemovalNotificationCallback()

void HDAGraphicsPowerRemovalNotificationCallback	(	PVOID	GraphicsDeviceHandle,
		PVOID	PrivateHandle
	)

Definition at line 74 of file sgpc.cpp.

  {
    PFDO_CONTEXT fdoCtx = (PFDO_CONTEXT)PrivateHandle;
    UNREFERENCED_PARAMETER(GraphicsDeviceHandle);
    UNREFERENCED_PARAMETER(fdoCtx);
    //No-Op
}

Referenced by HDAGraphicsPowerInterfaceAdd().