WinDriver FAQs

A device driver is a software module that controls hardware. In today's operating systems, this software module usually resides in the kernel mode (ring 0). However, WinDriver enables you to write this code in the user mode, utilizing our lower-level kernel driver(s), and thus frees you from the need for any driver development knowledge. For a better understanding of the basic WinDriver architecture, refer to the WinDriver Architecture page on our site.
WinDriver also includes the Kernel PlugIn feature, which allows you to 'drop' sections of your user-mode code into the kernel mode for better performance and greater flexibility (for PCI/CardBus/PCMCIA/PCI Express/ISA).
Whether the code you develop resides in the user mode or the kernel mode, it is still the code driving the hardware, and therefore it is a driver (but you can call it anything you like...).

Using WinDriver, you gain the following benefits:

• Cost — Save 90% of the development time.


• Reliability — WinDriver has been market tested thoroughly in thousands of applications (see the Testimonials page for more on this). It has been debugged on almost every platform in the market. Therefore it not only speeds your development time, but cuts your debugging time as well.


• Time to market — WinDriver is ready for you today. Using WinDriver will drastically shorten your development cycle.


• Flexibility — WinDriver supports multiple operating systems, such as Windows 7, Vista, Server 2008, Server 2003, XP, 2000, NT 4.0, Me, 98, Windows CE, Linux, Solaris, and VxWorks (depending on the version you are using) — so even if you only need your driver on one platform today, using WinDriver gives you the flexibility of running under any platform tomorrow. (Please refer to Technical Document #4 for a list of the supported operating systems for each type of hardware — PCI/ISA/USB).


• Stability — WinDriver keeps you away from the OS kernel. While our pre-written kernel module is doing all the transactions with your hardware, you write your code in the protected application mode. This way you get a kernel mode driver (written by our experienced developers), which was tested on practically any OS/platform/BIOS combination available and was found rock stable.

Not at all. With WinDriver, you are coding your device driver in the user mode. WinDriver already provides you with the lower level kernel mode driver, which implements the WinDriver API (see the WinDriver Architecture page on our site). You can, therefore, use your favorite development environment to program and debug your driver, in the user mode, thereby drastically decreasing your device driver development time.

Simply order the product from our On-line Store or download a Text Order Form and email it to: sales@jungo.com, or Fax it to us to the numbers indicated in the contact details on our site for the Driver Tools and Software Components department.

Your registered license will include the registered WinDriver version, official documentation and 2 months of free product upgrades and technical day support.

To get technical support or be eligible for version upgrades after the expiration of the complimentary two months support and maintenance period, you must subscribe to the WinDriver annual Upgrade & Support plan. You can subscribe to this plan from the On-Line Store.
For more information regarding the support & maintenance plan, refer to the Support Purchase page. A full price list can be found in the On-line Store (the price is derived from the price of the original license). As you will be able to see, it is much cheaper to subscribe to the upgrade and support plan during the period of a current valid upgrade & support subscription (including the 2 months complimentary upgrade & support period). Once you subscribe to this plan, use Jungo's Secured Support Center (or the Non-Secured Support Center) to contact our support team at any time. Please also refer to the following FAQ to find out how to report a problem effectively: http://www.jungo.com/st/support/faq.html#lfc.

After purchasing the license from Jungo, you own your driver. The license is issued for the development stage. The executable/DLL that you create is yours to distribute freely, in as many copies as you wish. No royalties are to be paid to Jungo. The only exception to this is if you have created a driver development kit with WinDriver. For this reason you cannot distribute the WinDriver header files or your license registration string, thereby enabling others to develop a driver with WinDriver. For more information, take a look at the Distributing Your Driver — Legal Issues Appendix in the WinDriver User's Manual or contact sales@jungo.com.

When using a registered version of WinDriver, you must register your specific license registration string from the code.

The generated DriverWizard code for the registered tool-kit will already include the relevant code for registering your license (provided you have activated your license from the wizard before generating the code). However, if you used the DriverWizard to generate the code during the evaluation period, or if you are using one of the WinDriver samples, you will need to add the registration code yourself.

Note that after the initial registration of the license from the DriverWizard, your license string will automatically be activated with every session of the wizard. This is the reason that you have found that your code seems to work if you first run DriverWizard (since the license was already registered from the wizard, even though it was not explicitly registered from the code).

Please refer to the description of WDU_Init() (USB) / WDC_DriverOpen() (PCI/ISA) in the WinDriver User's Manual to learn how to correctly register your license registration string from the code.
If your codes uses the low-level WD_xxx APIs instead of the WDU or WDC APIs, use the function WD_License() to register your license string. WD_License() is described in the WinDriver PCI Low-Level API Reference — WinDriver/docs/wdpci_low_level_api_ref.pdf — in v8.0.0 and above of WinDriver. In earlier versions the function is described in the WinDriver User's Manual, which is found under the WinDriver/docs/ directory for the specific version. (If you are using version 5.0.5b or earlier of WinDriver, you can refer to the WinDriver/redist/register/register.txt registration file (respectively) for relevant registration instructions).

Beginning with version 5.2.0 of WinDriver, the generated DriverWizard evaluation code already includes the required license registration code, but using a demo license string. When moving to a registered version you simply need to replace the demo license string that is used in the call to WDU_Init() / WDC_DriverOpen() / WD_License() in the evaluation code with your specific license registration string.

NOTE: Make sure that your code calls the license registration function before any other WinDriver API call (apart from WD_Open or WD_Version(), when using the low-level WD_xxx APIs).

When installing WinDriver, the only thing that will be locked to one machine is the development environment — i.e., the DriverWizard (unless you are using a floating WinDriver license, which enables you to use the DriverWizard on any PC). Once you have written and built your code, you may install and run it on any machine you want. The device driver you create using WinDriver is yours to distribute in as many copies as you wish, royalties free, provided you do not distribute your own driver development kit (see the following FAQ: http://www.jungo.com/st/support/faq.html#MIP).
To find out how to distribute the driver you developed with WinDriver, please review the driver distribution chapter in your WinDriver User's Manual, and the distribution technical documents for your WinDriver version in the Licensing And Distribution section of the WinDriver Technical Documents. Please note that before distributing your driver you must register your license registration string from the code, as explained in the manual and in the following FAQs: http://www.jungo.com/st/support/faq.html#reg1 and http://www.jungo.com/st/support/faq.html#lfc19.

Back to Top

The Debug Monitor (a.k.a. Monitor Debug Messages, in older WinDriver versions) is an application program that logs detailed debugging information from the WinDriver kernel driver(s). This application is available in two versions: wddebug_gui — a fully graphical version; and wddebug — a console-mode version, which also supports GUI execution on Windows CE platforms (beginning with v10.0.1 of WinDriver).
Both versions of the Debug Monitor can be found at WinDriver/util; on Mac OS X, the GUI version can be found in the OS's /Applications folder.
For detailed information on this utility and how to use it, refer to the WinDriver User's Manual, and to the following Technical Documents:
#12 (wddebug_gui for Windows, Mac OS X, Linux, and Solaris), #13 (wddebug for Windows, Windows CE, Mac OS X, Linux, and Solaris), and #14 (wddebug for VxWorks).
For information regarding redirecting debug information from the Debug Monitor to a kernel debugger, refer to Technical Document #44.

NOTE: The Debug Monitor can also be run on target platforms on which only on the WinDriver driver(s), and not the entire WinDriver tool-kit, have been installed. This can be useful, for example, for debugging problems on your customers' platforms, as explained in the following FAQ:
http://www.jungo.com/st/support/faq.html#lfc6009.

Yes. You can select to send the debug information from the Debug Monitor to a kernel debugger, as explained in Technical Document #44.
On Windows, in order to save the debug information in case of a hang/crash, you will need to install the kernel debugger on another PC and establish a debug session between this PC and your development PC. For more information on what to do in case of a crash on Windows, refer to Technical Document #121. On Linux you will find the debug log, after reboot, in /var/log/messages.

How do I implement an accurate timer using WinDriver?

WinDriver provides an API for accurate sleep times (in 1 microseconds resolution) — WD_Sleep().

By default, WD_Sleep() performs a busy sleep.

If you need to perform a non-busy sleep:

• If a resolution of ~17,000 microseconds is sufficient for you, then you can either set up the SLEEP_NON_BUSY flag in the dwOptions field of the WD_SLEEP structure, which is passed to WD_Sleep(), in order to perform a non-busy sleep; Or use the standard OS sleep functions (e.g., Sleep(), WaitForSingleObject(), etc.). Using WD_Sleep() will maintain your code's portability, as opposed to the standard OS sleep functions.


• If you need a higher resolution, you can write a Kernel PlugIn application, using the Virtual Timer Device (VTD) API in Win95. The problem is that the code that will execute on the timer is kernel mode code. You will have to write code to transfer the data from user mode to kernel mode, and then transfer the results back from kernel mode to user mode.

YES! The code of the device driver you write runs in normal Win32 user mode. Therefore, you can compile and debug your code using MS Visual Studio / Visual C++.
Please refer to Technical Document #19 for more information regarding debugging your driver code with WinDriver.

The Kernel PlugIn is an integral part of the WinDriver PCI/ISA tool-kit.
No additional license or payment is required in order to use it.

If you are using Kernel PlugIn to develop a SYS driver for Windows 7/Vista/ Server 2008/Server 2003/XP/2k/NT or Windows Me/98, you need to install Microsoft's Windows Driver Kit (WDK), or the earlier Driver Development Kit (DDK) — depending on your target OS and WinDriver version — in order to successfully build your Kernel PlugIn driver.
For information regarding acquiring the WDK, refer to: http://www.microsoft.com/whdc/devtools/WDK/WDKpkg.mspx.
[Note that when using the WDK/DDK to build your Kernel PlugIn driver, you will also need to set the BASEDIR or DDKROOT environment variable to the location of your DDK library, as explained in the WinDriver User's Manual.]

Development of VxD Kernel PlugIn drivers, which was supported for Windows 98/Me in earlier versions of WinDriver (v6.0x-), does not require you to install Microsoft's WDK/DDK in order to successfully build the driver, unless you choose to add your own DDK function calls to your Kernel PlugIn application. (Note that using OS-specific DDK functions can damage the driver's portability).

Using WinDriver's Kernel PlugIn feature, you can expect to handle more than 100,000 interrupts per second, without missing any of them.
For sample Kernel PlugIn interrupt handling code, use the DriverWizard to generate code for your device (for PCI and PCMCIA devices, define the data for clearing the interrupt in the wizard before generating the code), or take a look at the WinDriver Kernel PlugIn sample code — KP_PCI (WinDriver/samples/pci_diag/kp_pci — v7.0.0+) or KPTEST (WinDriver/kerplug/kptest/kermode — v6.2.3-a).

In the user mode you can handle around 5,000-10,000 interrupts per second, but since Windows is not a Real Time OS, you might miss some of the interrupts once in a while (although WinDriver tells you when you have missed an interrupt and how many interrupts were missed).

For an explanation regarding interrupt latency with WinDriver, refer to Technical Document #48.

Yes.

WinDriver implements malloc() and free() for kernel mode memory allocation (see Technical Document #34). Since the allocated memory is locked, you can also use this memory in your Kernel PlugIn interrupt routines.
You can also share a memory buffer between the user mode and Kernel PlugIn applications — as explained in Technical Document #41.

Yes — You can erase the user mode interrupt handler routine.
You can also implement some of the interrupt handling in the Kernel PlugIn and some of it in the user mode. The return value of KP_IntAtDpc() (which is called when the high-priority KP_IntIrql() routine returns TRUE) determines the number of times that the user mode interrupt handler routine will be executed (if at all).

Kernel PlugIn enables you to create an add-on *.sys/.kext/.o/.ko kernel driver — depending on your OS — to extend the features of WinDriver for your needs. The Kernel PlugIn driver your create is not standalone — it can only work together with a user-mode driver that activates it.

Note that when using WinDriver's Kernel PlugIn feature, you must also install the WinDriver kernel module — windrvr6.sys/.dll/.o/.ko or WinDriver.kext, depending on the OS and the WinDriver version.

When writing device drivers, developers must write a separate device driver for the Win 9x and the Win NTx kernels. Microsoft has developed a cross-platform operating system support for input devices, in order to provide a uniform way for code to access such devices across Windows 7, Vista, Server 2008, Server 2003, XP, 2000, 98, and Me platforms. This new support is known as Windows Driver Model or "WDM". WDM is based on the original Windows NT driver model, with modifications to support Plug-and-Play and power management, and is used for most multimedia device types and many other newer device types, such as USB and 1394 devices.
Beginning with version 5.2.0 of WinDriver, WinDriver's kernel module — (windrvr6.sys / windrvr.sys in v5.2.2-) — which implements WinDriver's API, is a full WDM driver.

This message is not actually an error message and is not an indication of any problem in the installation process or with the driver. This message is issued by Microsoft's Windows XP to indicate that the driver was not tested and digitally signed by Microsoft's Windows Hardware Quality Labs (WHQL).

To avoid this message you can contact Microsoft in order to get your driver digitally signed. For more information Click Here.

WinDriver is fully WHQL-compliant. The driver you develop with WinDriver for Windows can be submitted to Microsoft's Windows Hardware Quality Labs (WHQL) testing in order to digitally sign the driver with Microsoft. Several WinDriver customers have already successfully signed their WinDriver-based drivers with Microsoft.
For more information on Microsoft's WHQL testing and how to get a WHQL certification for your hardware and WinDriver-based driver, refer to to the "WHQL Certification" section in the WinDriver User's Manual and to Microsoft's documentation, for example: http://www.microsoft.com/whdc/whql/default.mspx/. For further assistance, contact us via our Secured Support Center (or the Non-Secured Support Center).

Back to Top

Yes — the Debug Monitor utility is also available on Windows CE.
Please refer to Technical Document #13 for more information.

Yes. In Windows CE, device drivers, including NDIS drivers, are DLLs. So a NDIS network driver can use the WinDriver CE API to talk to the hardware.

Yes. In Windows CE, device drivers, including NDIS drivers, are DLLs. So a NDIS network driver can use the WinDriver CE API to talk to the hardware.

Back to Top

Make sure to install the WinDriver kernel module — windrvr6.o/.ko (or windrvr.o — in v5.2.2 or below) — before installing your Kernel PlugIn module, since the Kernel PlugIn driver depends on the WinDriver driver module for its operation.
For detailed Kernel PlugIn installation instructions, refer to the WinDriver User's Manual for your WinDriver version and to Technical Document #62.

This is a limitation in Linux kernels — by default you can allocate a maximum of 128KB for kernel buffer allocation. However, it is possible to recompile the kernel to get larger sizes and there is also a path that enables this — as explained in Technical Document #64.

Back to Top

Yes — you can use the Debug Monitor utility for VxWorks — wddebug.out — as explained in Technical Document #14.

These are utility functions included in the DriverBuilder's sample PCI library. You may have missed adding some C files to your project. Read the source file pci_lib.c (or pci_diag_lib.c) and check if it should be included in your project.

No, DriverBuilder is designed for writing device drivers. It cannot be used to develop a Board Support Package (BSP).

Back to Top

There are a number of possible causes for this:

• The Altera core gives you the opportunity to hardwire the BARs to an address. This means you would be assigning address space for your PCI functions manually. BARs should be hardwired to 0x00000000 and the hardwire BAR enable bits 5:0 of the enable bits parameter should also be set to zero if you are using a target PCI core. This will disable any hardwiring of BARs by the core. Altera says that the BAR hardwiring is used if you are using a Master-Target Core.


• The Altera core also gives the capability of enabling an expansion ROM — for example, the Altera PCI Development board that uses the pci_t32 (PCI target 32 bit Core). The core defaults to enabling the expansion ROM even though the board does not have an expansion ROM. The OS uses the expansion ROM to execute boot code. In order to disable the expansion ROM you may have to set the expansion ROM BAR to 0x00000000 and set bit 7 of the enable bits parameter (expansion ROM enable) to zero.

Back to Top

Yes. You can use the WinDriver PCI tool-kit and API to develop a CardBus driver, as explained in Technical Document #94.

Note that on Plug-and-Play (PnP) Windows operating systems, you need to generate and install an INF file for your device in order to successfully handle it with WinDriver (you can use the DriverWizard to generate the INF file, as explained in the WinDriver documentation). The INF file will register your device to work with WinDriver's kernel driver (windrvr6.sys or windrvr.sys — in v5.2.x / wdpnp.sys/wdusb.sys — in previous versions).

Back to Top

This might be a hardware problem, due to BIOS-specific implementations of parallel port modes on various computers. WinDriver cannot control this behavior, since it is programmed into the BIOS. We advise you to follow the brand of computer or BIOS that you have observed works correctly.

Back to Top

The user-mode interrupts handler can service up to 10,000 interrupts per second (although we cannot commit to a specific number, since this is dependent upon many factors). A latency of approximately 25ms should generally not happen, but it can from time to time. Using WinDriver's Kernel PlugIn feature will ensure that this will not happen. However, nothing can protect against some badly written device drivers that sometimes disable interrupts for long periods. Such offending drivers should be identified and upgraded or removed. For more information regarding WinDriver's interrupt latency, refer to Technical Document #48

When a PCI interrupt occurs, WinDriver writes/reads the interrupt status register in order to clear (acknowledge) the level sensitive interrupt. This is performed directly in the kernel, according to the information that was set up in the code, beforehand, when enabling the interrupt. To read and save the value of the interrupt register before the interrupt is cleared, so that you can later reference this value from within your interrupt handler routine, you need to set up a relevant read command in the interrupt transfer commands that are set up in the dwCmd field of the WD_INTERRUPT structure, which is passed to InterruptEnable() (/InterruptThreadEnable() in earlier versions)/WD_IntEnable(), and set the INTERRUPT_CMD_COPY flag in the dwOptions field of the WD_INTERRUPT structure (int.dwOptions |= INTERRUPT_CMD_COPY).
This is documented in the "Interrupt Handling" section of the WinDriver User's Manual and in Technical Documents #104 and #75.

To lock a large DMA buffer (more than 1MB), when using Scatter/Gather DMA (i.e., dwOptions is not set to KERNEL_BUFFER_ALLOC for Contiguous Buffer DMA), please follow these steps:

1. Set the DMA_LARGE_BUFFER flag in the dwOptions field of the WD_DMA structure. [This flag is only required when performing Scatter/Gather DMA, as opposed to Contiguous Buffer DMA.]


2. Calculate the number of pages you need to lock, in the following manner, and assign it to the dwPages field of the WD_DMA structure:
   
   dwPagesNeeded = transferCount / 4096 + 2;
   
   where transferCount is the number of bytes that you want to lock.


3. NOTE: By default the WD_DMA structure can hold information of up to 256 pages (= WD_DMA_PAGES, defined in WinDriver\include\windrvr.h). If you wish to lock more than 256 pages, you need to have enough memory to hold the information of all the pages. To allocate enough memory to hold the information (address and number of bytes) of the additional pages required, you can do the following:

           WD_DMA *pDma;
           pDma = (WD_DMA *)malloc(sizeof(WD_DMA) + sizeof(WD_DMA_PAGE)*(dwPagesNeeded - WD_DMA_PAGES));
           

If the memory allocation still fails, verify that there are sufficient system resources for the attempted memory allocation (both in the kernel and in the user mode address space, to which the memory is mapped).
On Windows, you may need to increase the size of the non-paged pool (from which the memory is allocated), as explained in Technical Document #58. If you still cannot lock the entire buffer, try locking a smaller buffer.

For more information regarding performing DMA with WinDriver, please see the section regarding "Performing DMA" in the "WinDriver Implementations Issues" chapter of the WinDriver User's Manual and to the description of the WinDriver DMA APIs in the "Function Reference" chapter of the manual.

"Regular" memory (stack, heap, etc.) is cached by the operating system. When using WD_DMALock(), the data is non-cached, in order to make it DMA safe. Therefore, the memory access is slower.
Note that this is the correct behavior for DMA.

Beginning with version 5.2.1 of WinDriver, when performing Contiguous Buffer DMA on Windows 7/Vista/Server 2008/Server 2003/XP/2000/NT, you can set the DMA_ALLOW_CACHE flag in the dwOptions field of the WD_DMA structure that is passed to WD_DMALock(), in order to allocate a cached DMA buffer. When using this flag, specify whether you wish to write to the device or read from the device, using DMA_READ_FROM_DEVICE or DMA_WRITE_TO_DEVICE

If you have allocated the memory in the user mode, and then passed its address to WD_DMALock() — i.e., if you performed Scatter/Gather DMA — then calling WD_DMAUnlock() will unlock the memory buffer and it will now function like other "regular" memory in terms of access speed.

Back to Top