DXGKCB_NOTIFY_INTERRUPT función de devolución de llamada (d3dkmddi.h)

Un controlador de miniporte de pantalla en modo kernel llama a DXGKCB_NOTIFY_INTERRUPT para informar al programador de la unidad de procesamiento gráfico (GPU) sobre una actualización de hardware gráfico en el momento de la rutina de servicio de interrupción (ISR).

Sintaxis

DXGKCB_NOTIFY_INTERRUPT DxgkcbNotifyInterrupt;

void DxgkcbNotifyInterrupt(
  [in] IN_CONST_HANDLE hAdapter,
  [in] IN_CONST_PDXGKARGCB_NOTIFY_INTERRUPT_DATA unnamedParam2
)
{...}

Parámetros

[in] hAdapter

Identificador del objeto de adaptador para la GPU. Un controlador recibe el identificador del miembro DeviceHandle de la estructura DXGKRNL_INTERFACE en una llamada a su función DxgkDdiStartDevice .

[in] unnamedParam2

Puntero a una estructura de DXGKARGCB_NOTIFY_INTERRUPT_DATA que contiene información de notificación para una interrupción.

Valor devuelto

None

Observaciones

Un controlador de minipuerto de pantalla llama a la función DXGKCB_NOTIFY_INTERRUPT para notificar una interrupción del hardware gráfico que define el tipo de enumeración DXGK_INTERRUPT_TYPE .

Normalmente, se llama a DXGKCB_NOTIFY_INTERRUPT desde la función DxgkDdiInterruptRoutine del controlador de minipuerto de pantalla, a la que se llama cuando se producen interrupciones del hardware gráfico. DXGKCB_NOTIFY_INTERRUPT informa al programador de GPU sobre una actualización de una barrera a través de una secuencia de acceso directo a memoria (DMA) al hardware gráfico.

Si el controlador de minipuerto de pantalla usa varios controladores de interrupción que corresponden a varios IRQL, el controlador no debe llamar a DXGKCB_NOTIFY_INTERRUPT de forma reentrante. Por lo tanto, en este caso, el controlador de minipuerto de pantalla siempre debe llamar a DXGKCB_NOTIFY_INTERRUPT desde un nivel fijo del controlador de interrupción.

Del mismo modo, si se usan interrupciones señaladas por mensajes, el controlador de minipuerto de pantalla puede llamar a DXGKCB_NOTIFY_INTERRUPT desde un controlador de interrupción que corresponde a un número de mensaje fijo. El controlador debe notificar el número de mensaje que se usa para la notificación en el miembro InterruptMessageNumber de la estructura DXGK_DRIVERCAPS , cuando el valor de enumeración DXGKQAITYPE_DRIVERCAPS se especifica en el miembro Type de la estructura DXGKARG_QUERYADAPTERINFO en una llamada a la función DxgkDdiQueryAdapterInfo del controlador.

Después de que el controlador de minipuerto de pantalla llame a DXGKCB_NOTIFY_INTERRUPT pero antes de que el controlador salga de su ISR, el controlador debe poner en cola una llamada a procedimiento diferido (DPC) mediante la función DxgkCbQueueDpc . Este DPC debe estar en cola porque también se debe notificar al programador de GPU, cuando la rutina de devolución de llamada DPC del controlador llama a la función DXGKCB_NOTIFY_DPC , aproximadamente el mismo evento en DPC. El sistema operativo solo puede realizar una determinada cantidad de procesamiento relacionado con los eventos de hardware gráficos en el momento de DPC.

Si el controlador de miniporte de pantalla determina que se desencadenó más de una interrupción en el hardware y el controlador debe llamar a DXGKCB_NOTIFY_INTERRUPT para cada interrupción para notificar la interrupción al sistema operativo, el controlador debe notificar interrupciones de tipo DMA antes de una interrupción de tipo CRTC. Para obtener más información sobre los tipos de interrupción, consulte DXGK_INTERRUPT_TYPE.

Los autores de llamadas de DXGKCB_NOTIFY_INTERRUPT se ejecutan en el nivel de interrupción (es decir, DIRQL, que es un IRQL entre DISPATCH_LEVEL y PROFILE_LEVEL, no inclusivo).

DXGKCB_XXX funciones se implementan mediante Dxgkrnl. Para usar esta función de devolución de llamada, llame a DxgkCbNotifyInterrupt a través del DXGKRNL_INTERFACE.

Ejemplos

En el ejemplo de código siguiente se muestra el código del motor de software que supervisa una cola de software y notifica al programador de GPU la finalización de paquetes.

typedef struct _SubmitParams {
    HW_DEVICE_EXTENSION *pHwDeviceExtension;
    UINT                NodeOrdinal;
    UINT                FenceID;
    UINT                PreemptionFenceID;
} SubmitParams;

BOOLEAN R200TEST_SWNode_SynchronizeVidSchNotifyInt(PVOID* params)
{
    SubmitParams  *pSchNotifyParams = (SubmitParams*)params;
    DXGKCB_NOTIFY_INTERRUPT  DxgkCbNotifyInterrupt;
    DXGKARGCB_NOTIFY_INTERRUPT_DATA  notifyInt = {0};

    DxgkCbNotifyInterrupt = (DXGKCB_NOTIFY_INTERRUPT)pSchNotifyParams->pHwDeviceExtension->pVidSchINTCB;

    if(!DxgkCbNotifyInterrupt) {
        return FALSE;
    }

    if(pSchNotifyParams->PreemptionFenceID) {
        notifyInt.InterruptType = DXGK_INTERRUPT_DMA_PREEMPTED;
        notifyInt.DmaPreempted.PreemptionFenceId = pSchNotifyParams->PreemptionFenceID;
        notifyInt.DmaPreempted.LastCompletedFenceId = pSchNotifyParams->FenceID;
        notifyInt.DmaPreempted.NodeOrdinal = pSchNotifyParams->NodeOrdinal;
    }
    else {
        notifyInt.InterruptType = DXGK_INTERRUPT_DMA_COMPLETED;
        notifyInt.DmaCompleted.SubmissionFenceId = pSchNotifyParams->FenceID;
        notifyInt.DmaCompleted.NodeOrdinal = pSchNotifyParams->NodeOrdinal;
    }

    DxgkCbNotifyInterrupt(pSchNotifyParams->pHwDeviceExtension->DeviceHandle, &notifyInt);

    pSchNotifyParams->pHwDeviceExtension->PrevSubmitFenceIDArray[pSchNotifyParams->NodeOrdinal] = pSchNotifyParams->FenceID;

    if(pSchNotifyParams->PreemptionFenceID) {
        pSchNotifyParams->pHwDeviceExtension->PrevPreemptFenceIDArray[pSchNotifyParams->NodeOrdinal] = pSchNotifyParams->PreemptionFenceID;
    }

    return TRUE;
}

Requisitos

Consulte también

DXGK_DRIVERCAPS

DXGKARGCB_NOTIFY_INTERRUPT_DATA

DXGKARG_QUERYADAPTERINFO

DXGKRNL_INTERFACE

DXGK_INTERRUPT_TYPE

DXGKCB_NOTIFY_DPC

DxgkCbQueueDpc

DxgkDdiInterruptRoutine

DxgkDdiQueryAdapterInfo

DxgkDdiStartDevice