• Called when the Kernel PlugIn driver is loaded.
Sets the name of the Kernel PlugIn driver and the KP_Open() [B.6.2] callback function.

BOOL __cdecl KP_Init(KP_INIT *kpInit);

TRUE if successful. Otherwise FALSE.

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 re-compile 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;
  strcpy (kpInit->cDriverName, "KPDriver");  /* Up to 12 chars */

  return TRUE;
}

• Called when WD_KernelPlugInOpen() (see the WinDriver PCI Low-Level API Reference) is called from user mode.
WD_KernelPlugInOpen() is automatically called from the WDC_xxxDeviceOpen() functions (PCI [B.3.10] / PCMCIA [B.3.11] / ISA [B.3.12]) when these functions are called with a valid Kernel PlugIn driver (set in the pcKPDriverName parameter).

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, etc.).
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.
For devices that have been opened with a Kernel PlugIn driver – i.e., WDC_xxxDeviceOpen() (PCI [B.3.10] / PCMCIA [B.3.11] / ISA [B.3.12]) was called with a valid Kernel PlugIn driver (set in the pcKPDriverName parameter) – the WDC_xxxDeviceClose() functions (PCI [B.3.13] / PCMCIA [B.3.14] / ISA [B.3.15]) automatically call WD_KernelPlugInClose() in order to close the handle to the Kernel PlugIn driver.

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

None

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.

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).

The interrupt context that is set by this function (*ppIntContext) will be passed to the rest of the Kernel PlugIn interrupt functions.

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

Returns TRUE if enable is successful; otherwise returns FALSE.

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).

void __cdecl KP_IntDisable(PVOID pIntContext);

None

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.