DXGKCB_NOTIFY_INTERRUPT funzione di callback (d3dkmddi.h)

Un driver miniport in modalità kernel chiama DXGKCB_NOTIFY_INTERRUPT per informare l'utilità di pianificazione dell'unità di elaborazione grafica (GPU) su un aggiornamento hardware grafico in fase di interruzione della routine del servizio (ISR).

Sintassi

DXGKCB_NOTIFY_INTERRUPT DxgkcbNotifyInterrupt;

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

Parametri

[in] hAdapter

Handle per l'oggetto adapter per la GPU. Un driver riceve l'handle dal membro DeviceHandle della struttura DXGKRNL_INTERFACE in una chiamata alla relativa funzione DxgkDdiStartDevice .

[in] unnamedParam2

Puntatore a una struttura DXGKARGCB_NOTIFY_INTERRUPT_DATA che contiene informazioni di notifica per un interruzione.

Valore restituito

nessuno

Osservazioni

Un driver miniport visualizzato chiama la funzione DXGKCB_NOTIFY_INTERRUPT per segnalare un interruzione hardware grafica che definisce il tipo di enumerazione DXGK_INTERRUPT_TYPE .

In genere, DXGKCB_NOTIFY_INTERRUPT viene chiamato dalla funzione DxgkDdiInterruptRoutine (ISR), chiamata quando si verificano interruzioni hardware grafiche. DXGKCB_NOTIFY_INTERRUPT informa l'utilità di pianificazione GPU su un aggiornamento a una recinzione tramite un flusso DMA (Direct Memory Access) all'hardware grafico.

Se il driver miniport visualizzato usa più gestori di interruzione che corrispondono a più IRQLs, il driver non deve chiamare DXGKCB_NOTIFY_INTERRUPT in modo reentrant. Pertanto, in questo caso, il driver miniport visualizzato deve sempre chiamare DXGKCB_NOTIFY_INTERRUPT da un livello fisso del gestore di interruzioni.

Analogamente, se vengono usati interruzioni con segnale di messaggio, il driver miniport visualizzato può chiamare DXGKCB_NOTIFY_INTERRUPT da un gestore di interruzioni che corrisponde a un numero di messaggio fisso. Il driver deve segnalare il numero di messaggio utilizzato per la notifica nel membro InterruptMessageNumberdella strutturaDXGK_DRIVERCAPS, quando il valore di enumerazione DXGKQAITYPE_DRIVERCAPS viene specificato nel membro Type della struttura DXGKARG_QUERYADAPTERINFO in una chiamata alla funzione DxgkDdiQueryAdapterInfo del driver.

Dopo che il driver miniport visualizzato chiama DXGKCB_NOTIFY_INTERRUPT ma prima dell'uscita dal driver ISR, il driver deve accodare una chiamata di procedura posticipata (DPC) usando la funzione DxgkCbQueueDpc . Questo DPC deve essere accodato perché l'utilità di pianificazione GPU deve essere notificata anche quando la routine di callback DPC del driver chiama la funzione di DXGKCB_NOTIFY_DPC , circa lo stesso evento in fase di DPC. Una determinata quantità di elaborazione correlata agli eventi hardware grafici può essere eseguita solo dal sistema operativo in fase DPC.

Se il driver miniport visualizzato determina che più interruzioni sono state attivate nell'hardware e il driver deve chiamare DXGKCB_NOTIFY_INTERRUPT per ogni interruzione per segnalare l'interruzione al sistema operativo, il driver deve segnalare interruzioni di tipo DMA prima di un interruzione di tipo CRTC. Per altre informazioni sui tipi di interruzione, vedere DXGK_INTERRUPT_TYPE.

I chiamanti di DXGKCB_NOTIFY_INTERRUPT vengono eseguiti a livello di interruzione, ovvero DIRQL, ovvero irQL tra DISPATCH_LEVEL e PROFILE_LEVEL, non inclusivo.

DXGKCB_XXX funzioni vengono implementate da Dxgkrnl. Per usare questa funzione di callback, chiamare DxgkCbNotifyInterrupt tramite il DXGKRNL_INTERFACE.

Esempio

Nell'esempio di codice seguente viene illustrato il codice del motore software che monitora una coda software e notifica al programmatore GPU il completamento dei pacchetti.

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;
}

Requisiti

Vedi anche

DXGK_DRIVERCAPS

DXGKARGCB_NOTIFY_INTERRUPT_DATA

DXGKARG_QUERYADAPTERINFO

DXGKRNL_INTERFACE

DXGK_INTERRUPT_TYPE

DXGKCB_NOTIFY_DPC

DxgkCbQueueDpc

DxgkDdiInterruptRoutine

DxgkDdiQueryAdapterInfo

DxgkDdiStartDevice