Kernel PlugIn initialization function.
This function is called when the Kernel PlugIn driver is loaded.
The function sets the name of the Kernel PlugIn driver and the KP_Open callback function(s) [B.6.2].

BOOL __cdecl KP_Init(KP_INIT *kpInit);

TRUE if successful. Otherwise FALSE.

You must define the KP_Init function in your code in order to link the Kernel PlugIn driver to WinDriver. KP_Init is called when the driver is loaded. Any code that you want to execute upon loading should be in this function.

BOOL __cdecl KP_Init(KP_INIT *kpInit)
{
    /* Check if the version of the WinDriver Kernel
       PlugIn library is the same version
       as windrvr.h and wd_kp.h */
    if (kpInit->dwVerWD != WD_VER)
    {
        /* You need to recompile your Kernel PlugIn
           with the compatible version of the WinDriver
           Kernel PlugIn library, windrvr.h and wd_kp.h */
       return FALSE;
    }

    kpInit->funcOpen = KP_Open;
    kpInit->funcOpen_32_64 = KP_PCI_VIRT_Open_32_64;
    strcpy (kpInit->cDriverName, "KPDriver"); /* Up to 12 chars */

  return TRUE;
}

Kernel PlugIn open function.
This function sets the rest of the Kernel PlugIn callback functions (KP_Call [B.6.4], KP_IntEnable [B.6.6], etc.) and performs any other desired initialization (such as allocating memory for the driver context and filling it with data passed from the user mode).
The returned driver context (*ppDrvContext) will be passed to rest of the Kernel PlugIn callback functions.

BOOL __cdecl KP_Open(
    KP_OPEN_CALL *kpOpenCall,
    HANDLE hWD,
    PVOID pOpenData,
    PVOID *ppDrvContext);

TRUE if successful. If FALSE, the call to WD_KernelPlugInOpen() from the user mode will fail.

BOOL __cdecl KP_Open(KP_OPEN_CALL *kpOpenCall, HANDLE hWD,
            PVOID pOpenData, PVOID *ppDrvContext)
{
    kpOpenCall->funcClose = KP_Close;
    kpOpenCall->funcCall = KP_Call;
    kpOpenCall->funcIntEnable = KP_IntEnable;
    kpOpenCall->funcIntDisable = KP_IntDisable;
    kpOpenCall->funcIntAtIrql = KP_IntAtIrql;
    kpOpenCall->funcIntAtDpc = KP_IntAtDpc;
    kpOpenCall->funcIntAtIrqlMSI = KP_IntAtIrqlMSI;
    kpOpenCall->funcIntAtDpcMSI = KP_IntAtDpcMSI;
    kpOpenCall->funcEvent = KP_Event;

    /* You can allocate driver context memory here: */
    *ppDrvContext = malloc(sizeof(MYDRV_STRUCT));
    return *ppDrvContext!=NULL;
}

Called when WD_KernelPlugInClose() (see the WinDriver PCI Low-Level API Reference) is called from user mode.
The high-level WDC_xxxDeviceClose() functions (PCI [B.3.13] / PCMCIA [B.3.14] / ISA [B.3.15]) automatically call WD_KernelPlugInClose() for devices that contain an open Kernel PlugIn handle (see Section 12.4).

This functions can be used to perform any required clean-up for the Kernel PlugIn (such as freeing memory previously allocated for the driver context, etc.).

void __cdecl KP_Close(PVOID pDrvContext);

void __cdecl KP_Close(PVOID pDrvContext)
{
   if (pDrvContext)
        free(pDrvContext); /* Free allocated driver context memory */
}

Called when the user-mode application calls WDC_CallKerPlug() [B.3.18] (or the low-level WD_KernelPlugInCall() function — see the WinDriver PCI Low-Level API Reference).

This function is a message handler for your utility functions.

void __cdecl KP_Call(
    PVOID pDrvContext,
    WD_KERNEL_PLUGIN_CALL
    *kpCall,
    BOOL fIsKernelMode);

None

void __cdecl KP_Call(PVOID pDrvContext,
   WD_KERNEL_PLUGIN_CALL *kpCall, BOOL fIsKernelMode)
{
    kpCall->dwResult = MY_DRV_OK;
    switch (kpCall->dwMessage)
    {
        /* In this sample we implement a GetVersion message */
        case MY_DRV_MSG_VERSION:
            {
              DWORD dwVer = 100;
              MY_DRV_VERSION *ver = (MY_DRV_VERSION *)kpCall->pData;
              COPY_TO_USER_OR_KERNEL(&ver->dwVer, &dwVer,
                  sizeof(DWORD), fIsKernelMode);
              COPY_TO_USER_OR_KERNEL(ver->cVer, "My Driver V1.00",
                  sizeof("My Driver V1.00")+1, fIsKernelMode);

              kpCall->dwResult = MY_DRV_OK;
            }
            break;
        /* You can implement other messages here */
        default:
            kpCall->dwResult = MY_DRV_NO_IMPL_MESSAGE;
    }
}

Called when a Plug-and-Play or power management event for the device is received, provided the user-mode application first called WDC_EventRegister() [B.3.49] with fUseKP = TRUE (or the low-level EventRegister() function with a Kernel PlugIn handle — see WinDriver PCI Low-Level API Reference) (see the Remarks below).

BOOL __cdecl KP_Event(
    PVOID pDrvContext,
    WD_EVENT *wd_event);

TRUE in order to notify the user about the event.

KP_Event will be called if the user mode process called WDC_EventRegister() [B.3.49] with fUseKP= TRUE (or of the low-level EventRegister() function was called with a Kernel PlugIn handle — see the WinDriver PCI Low-Level API Reference).

BOOL __cdecl KP_Event(PVOID pDrvContext, WD_EVENT *wd_event)
{
    /* Handle the event here */
    return TRUE; /* Return TRUE to notify the user about the event */
}

Called when WD_IntEnable() (see WinDriver PCI Low-Level API Reference) is called from the user mode with a Kernel PlugIn handle.
WD_IntEnable() is called automatically from WDC_IntEnable() [B.3.46] and InterruptEnable() (see WinDriver PCI Low-Level API Reference).

BOOL __cdecl KP_IntEnable (
    PVOID pDrvContext,
    WD_KERNEL_PLUGIN_CALL *kpCall,
    PVOID *ppIntContext);

Returns TRUE if enable is successful; otherwise returns FALSE.

This function should contain any initialization needed for your Kernel PlugIn interrupt handling.

BOOL __cdecl KP_IntEnable(PVOID pDrvContext,
     WD_KERNEL_PLUGIN_CALL *kpCall, PVOID *ppIntContext)
{
    DWORD *pIntCount;
    /* You can allocate specific memory for each interrupt
       in *ppIntContext */
    *ppIntContext = malloc(sizeof (DWORD));
    if (!*ppIntContext)
        return FALSE;
    /* In this sample the information is a DWORD used to
       count the incoming interrupts */
    pIntCount = (DWORD *) *ppIntContext;
    *pIntCount = 0; /* Reset the count to zero */
    return TRUE;
}

Called when WD_IntDisable() (see WinDriver PCI Low-Level API Reference) is called from the user mode for interrupts that were enabled in the Kernel PlugIn.
WD_IntDisable() is called automatically from WDC_IntDisable() [B.3.47] and InterruptDisable() (see WinDriver PCI Low-Level API Reference).

This function should free any memory that was allocated in KP_IntEnable [B.6.6].

void __cdecl KP_IntDisable(PVOID pIntContext);

void __cdecl KP_IntDisable(PVOID pIntContext)
{
  /* You can free the interrupt specific memory
     allocated to pIntContext here */
  free(pIntContext);
}

High-priority legacy interrupt handler routine, which is run at high interrupt request level. This function is called upon the arrival of a legacy interrupt that has been enabled using a Kernel PlugIn driver — see the description of WDC_IntEnable() [B.3.46] or the low-level InterruptEnable() and WD_IntEnable() functions (see WinDriver PCI Low-Level API Reference).

BOOL __cdecl KP_IntAtIrql(
    PVOID pIntContext,
    BOOL *pfIsMyInterrupt);

TRUE if deferred interrupt processing (DPC) is required; otherwise FALSE.

BOOL __cdecl KP_IntAtIrql(PVOID pIntContext,
    BOOL *pfIsMyInterrupt)
{
    DWORD *pdwIntCount = (DWORD*)pIntContext;

    /* Check your hardware here to see if the interrupt belongs to you.
       If it does, you must set *pfIsMyInterrupt to TRUE.
       Otherwise, set *pfIsMyInterrupt to FALSE. */
    *pfIsMyInterrupt = FALSE;

    /* In this example we will schedule a DPC once in every 5 interrupts */
    (*pdwIntCount) ++;
    if (*pdwIntCount==5)
    {
        *pdwIntCount = 0;
        return TRUE;
    }

    return FALSE;
}

Deferred processing legacy interrupt handler routine.
This function is called once the high-priority legacy interrupt handling is completed, provided that KP_IntAtIrql [B.6.8] returned TRUE.

DWORD __cdecl KP_IntAtDpc(
    PVOID pIntContext,
    DWORD dwCount);

Returns the number of times to notify user mode (i.e., return from WD_IntWait() — see the WinDriver PCI Low-Level API Reference).

DWORD __cdecl KP_IntAtDpc(PVOID pIntContext, DWORD dwCount)
{
  /* Return WD_IntWait as many times as KP_IntAtIrql
     scheduled KP_IntAtDpc */
  return dwCount;
}

High-priority Message-Signaled Interrupts (MSI) / Extended Message-Signaled Interrupts (MSI-X) handler routine, which is run at high interrupt request level. This function is called upon the arrival of an MSI/MSI-X that has been enabled using a Kernel PlugIn — see the description of WDC_IntEnable() [B.3.46] or the low-level InterruptEnable() and WD_IntEnable() functions (see WinDriver PCI Low-Level API Reference).

BOOL __cdecl KP_PCI_IntAtIrqlMSI(
    PVOID pIntContext,
    ULONG dwLastMessage,
    DWORD dwReserved);

TRUE if deferred MSI/MSI-X processing (DPC) is required; otherwise FALSE.

BOOL __cdecl KP_PCI_IntAtIrqlMSI(PVOID pIntContext,
    ULONG dwLastMessage, DWORD dwReserved)
{
    return TRUE;
}

Deferred processing Message-Signaled Interrupts (MSI) / Extended Message-Signaled Interrupts (MSI-X) handler routine.
This function is called once the high-priority MSI/MSI-X handling is completed, provided that KP_IntAtIrqlMSI [B.6.10] returned TRUE.

DWORD __cdecl KP_IntAtDpcMSI(
  PVOID pIntContext,
  DWORD dwCount,
  ULONG dwLastMessage,
  DWORD dwReserved);

Returns the number of times to notify user mode (i.e., return from WD_IntWait() — see the WinDriver PCI Low-Level API Reference).

DWORD __cdecl KP_IntAtDpcMSI(PVOID pIntContext, DWORD dwCount,
  ULONG dwLastMessage, DWORD dwReserved)
{
  /* Return WD_IntWait as many times as KP_IntAtIrqlMSI
     scheduled KP_IntAtDpcMSI */
  return dwCount;
}

Macros for copying data from the user mode to the Kernel PlugIn and vice versa.