Answers

General Starters FAQs

With WinDriver I don’t have to program in the kernel mode. So I’m not really creating a driver, am I?

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 User's Manuals.

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

Why should I buy WinDriver and not develop a device driver on my own?

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 Customer Success Stories 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 10/8.1/Server 2012 R2/8/Server 2012/7/Server 2008 R2/Server 2008/Server 2003/XP, Embedded Windows 10/8.1/8/7, Windows CE/Mobile, and Linux (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.

Must I have experience in device driver or kernel programming?

Not at all. With WinDriver, you are coding your device driver in the user mode. WinDriver already provides you with the low-level kernel mode driver, which implements the WinDriver API (see the WinDriver architecture overview in the WinDriver User's Manuals). 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.

Recommended development steps:

Start DriverWizard — WinDriver/wizard/wdwizard (or /Applications/wdwizard.app on Mac OS X — in WinDriver versions that support this OS). On Windows, you can also run the DriverWizard using the shortcut icon on your desktop, or from Windows’ Start menu: Start --> Programs --> WinDriver --> DriverWizard.

Use the graphical DriverWizard to easily diagnose your hardware, without writing a single line of code. For PCI/ISA — read/write the hardware resources (memory/IO/registers) and listen to interrupts.
For USB — transfer data on the pipes, reset the device, etc.

Select the “Generate Code” option from the toolbar, or press the Next button. Select your target compiler/development environment, and let the DriverWizard create a skeleton of a device driver application for your device. The generated code will include convenience structures and functions, which utilize WinDriver’s basic API to access the resources detected and defined (by you) for your hardware.You can use the DriverWizard to generate code in C, C#, or Visual Basic .NET (VB.NET) (USB only); earlier versions (until v11.2.0) also supported code generation in Delphi (Pascal) or Visual Basic (VB 6.0). The DriverWizard will also create makefiles and the relevant build environment for leading 32-bit and 64-bit compilers — such as MS Visual Studio, GCC, or Windows GCC MinGW/Cygwin.You can also use one of the WinDriver samples as the basis for your development. Specific samples for enhanced-support hardware can be found under the relevant directory for that hardware, such as PLX and Altera; see the WinDriver User's Manuals for your version of WinDriver for more information regarding WinDriver’s enhanced support for specific chip sets.
General samples, in C, can be found in the WinDriver/samples directory.
.NET samples are found in the WinDriver/csharp.net (C#) and WinDriver/vb.net (VB.NET) directories (beginning with v7.0.0 of WinDriver).

Use the manual and help files to modify the generated diagnostics code and add the specific functionality that you need (if any), in accordance with your hardware’s specification.
The WinDriver user’s manuals and help files are found in the WinDriver/docs directory and can also be accessed via Windows’ Start menu (for Windows users). All documents are also available online from the WinDriver Support page.

Compile and build your code (from the user mode!) using any 32-bit or 64-bit compiler.

DONE!

Can I try before I buy?

Yes. Jungo Connectivity provides full-featured evaluation versions of the WinDriver toolkit. You can download trial versions from our site.
The limitations of each evaluation version (as compared with the registered version) are outlined in the WinDriver User's Manuals and in Technical Document 9.

Is WinDriver fully backward compatible?

Until v11.5.0 WinDriver was fully backward compatible, except for rare occasions documented in the WinDriver Release Notes. This means that in most cases, code compiled with an earlier WinDriver version would work, without recompilation, with a driver from a newer version, with the possible need to also replace the device INF file on Windows with one from the newer version.
Staring from v11.5.0, when upgrading to a new version of WinDriver you must rebuild your code with a new license string for the new version. The WinDriver API is still for the most part backward compatible, but on occasion you may need to modify your code or project settings when rebuilding it with the header files from a newer version, to accommodate changes done in newer versions.

NOTE

The Kernel PlugIn is not backward compatible (in all versions). Therefore, when upgrading to a newer version of WinDriver you must also rebuild your Kernel PlugIn driver (if you have created such a driver) with the new version.

It is highly recommended to always use the newest WinDriver API, to fully utilize the improvements introduced in newer versions.

For detailed instructions on how to upgrade your driver to a newer WinDriver version, refer to Technical Document 131.

How do I report a problem effectively?

First, review the support resources available on the WinDriver Support page. If you cannot find an answer to your problem, use our Support Center to report a problem or get any type of product support.
To ensure a quick and effective response, be sure to specify all relevant information, as outlined in the support center and below.
You can also contact us by telephone. If you call outside our office hours, or if all support personnel are occupied, leave your full contact details (name, company name, email, and phone numbers) and we will be sure to contact you shortly.

When reporting a problem, please include a clear description of all the steps you performed, and specify which step failed and what was the exact nature of the failure or erroneous behavior that you encountered (including complete error messages).

Please check specifically that you have included the following information:

The entire output of the Debug Monitor utility: Run the Debug Monitor, set the debug level to “Trace”, reproduce your problem and attach the output from the Debug Monitor window (including the version information at the top).

For licensing problems: In addition to the Debug Monitor log, please be sure to specify your full license registration string, which you received when purchasing the software, and your development computer’s registration code. You can view the license registration string and the PC registration code from the DriverWizard’s Licensing Information window (File --> Registration Options).

For PCI related problems: In addition to the Debug Monitor log, please also attach the entire output of the pci_dump utility (found in the WinDriver/util directory), and be be sure to specify your card’s vendor ID and device ID as well.

For installation related problems, in addition to the Debug Monitor output, be sure to specify the exact installation steps that you performed (which files were copied to which directories; usage of the wdreg installation utility; installation of INF files; etc.) and the result of each step, and attach a copy of the exact error message that you received (if any).
On Plug-and-Play Windows platforms (Windows 98 and higher, not including Windows NT 4.0), please also attach a copy of the device INF file that was used in the installation (if any), and a copy of the %WINDIR%\setupapi.log file from the PC on which the problem occurred.

I installed WinDriver on a Windows PC about 40 days ago and forgot aboutit. Now, when I try to evaluate it I get a message notifying me that theevaluation period expired. Uninstalling and reinstalling the software does nothelp.

To completely remove WinDriver from your computer, follow the WinDriver uninstall instructions on our site.
NOTE: The online uninstall instructions are for the latest WinDriver version. If you are using an older version, follow the uninstall instructions in the WinDriver User’s Manual for your specific version.

Pricing and Licensing FAQs

How do I purchase my WinDriver license?

View the WinDriver prices, and get an online price quote for your specific development needs. Then submit an official quote request (from the same page), and follow the instructions you receive from our representative by email. Alternatively, you can download the WinDriver order form and email or fax it to us, or call us to order by phone. The updated contact information can be found on the WinDriver price-list and price-quote pages.

What will I receive with my license?

Your registered license will include the registered WinDriver version, official documentation, and 2 months of free product upgrades and technical day support. A single license entitles allows a single developer seat, and royalty free distribution of the driver with a single VID/PID and SKU end product.

How do I get technical support and maintenance after 2 months?

To get technical support or be eligible for version upgrades after the expiration of the complimentary two-months support and upgrade period, you must subscribe to the WinDriver annual Support and Upgrade plan. You can subscribe to this plan from the WinDriver price quote page.
For more information on this plan, refer to the WinDriver Support and Upgrade plan page.
The prices of the support plans are derived from the prices of the original WinDriver licenses. As you will be able to see, it is much cheaper to subscribe to the upgrade and support plan during the period of a valid Support and Upgrade plan (including the 2-months complimentary support and upgrade period). Once you subscribe to this plan, use Jungo Connectivity‘s Support Center to contact our support team at any time. Please also refer to FAQ #lfc to find out how to report a problem effectively.

What does a single WinDriver license cover in terms of development and distribution?

A single WinDriver license allows development on one PC, of a single application (SKU) for a single VID/PID board. Distribution of the WinDriver redistributable components is allowed only for the SKU/VID/PID. Each additional SKU/VID/PID requires a separate WinDriver license. In addition, no API/SDK distribution is allowed – this requires a separate WinDriver license.

How many copies of my application can I distribute, after developing it with WinDriver? Must I pay royalties?

After purchasing the license from Jungo Connectivity, the executable/DLL that you create can be distribute royalty free as part of your application, in as many copies as you wish, provided you have purchased the appropriate licenses. License(s) for VID/PID, OS and Architecture should be purchased. Note such royalty-free distribution is only for Application SKU and VID/PID you have purchased license for. Furthermore, you may not expose any API/SDK in your application, or enable any sort of development on top of it – this requires a separate SDK license from Jungo Connectivity. For more information, take a look at the Distributing Your Driver — Legal Issues Appendix in the WinDriver User's Manual or contact [email protected].

After registering my evaluation version of WinDriver, my WinDriver application (which worked with the evaluation version) does not work unless I first run the DriverWizard. Once I reboot the PC, the program stops working again, until I start the DriverWizard. This is also true for the WinDriver sample programs. What is wrong?

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 toolkit 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 Manuals 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 file 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).

I developed a driver with WinDriver, but it only runs on the development machine that I used to create the driver. How can I distribute the driver to other machines?

When installing WinDriver, the only thing that will be locked to one machine is the development environment — i.e., the DriverWizard. 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: FAQ #MIP).
To find out how to distribute the driver you developed with WinDriver, review the driver distribution chapter in your WinDriver User’s Manual, and the distribution technical documents.
Note that before you distribute your driver you must register your license registration string from the code, as explained in the manual and in FAQs #reg1 and #lfc19.

General Technical Information FAQs

What is the Debug Monitor utility and how do I use it?

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, in WinDriver versions that support it, 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 Manuals and to Technical Documents 12 (wddebug_gui for Windows, Mac OS X, Linux, and Solaris), 13 (wddebug for Windows, Windows CE (including Windows Mobile), Mac OS X, Linux, and Solaris), and 14 (wddebug for VxWorks — last supported in WinDriver v5.2.2).
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 toolkit, have been installed. This can be useful, for example, for debugging problems on your customers’ platforms, as explained in FAQ #lfc6009.

My application hangs the system, so I cannot see the debug information in the Debug Monitor log. Is there a way to save the debug information in case of a system hang/crash?

Yes. You can select to send the debug information from the Debug Monitor to a kernel debugger, as explained in Technical Document 44. In addition, beginning with version 11.7.0 of WinDriver you can select to auto-save the Debug Monitor log, so it will be available to you after you restart the OS.
On Windows, in order to send the debug information to a kernel debugger you will first 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 21.
On Linux you will find the kernel debugger log in the /var/log/messages directory.

I need to define more than 20 “hardware items” (I/O, memory, and interrupts) for my ISA card. Therefore, I increased the value ofWD_CARD_ITEMS in the windrvr.h header file (due to the definition of the Item member of the WD_CARD structure as an array of WD_CARD_ITEMS WD_ITEMS structures).
But now WD_CardRegister() will not work. Why?

If you need to define more than WD_CARD_ITEMS items for your card (currently 20 items, according to the definition of WD_CARD_ITEMS in windrvr.h), do not modify the value of WD_CARD_ITEMS in the code, but instead, simply call WD_CardRegister() several times from your code, with different items each time. (It is not mandatory to lock all the resources on a specific card with a single WD_CardRegister() call.) Alternatively, consider grouping several memory/IO address ranges into a single BAR definition, so that the overall resources item count does not exceed the default 20 items limit.

Please do not change anything in windrvr.h. The affect will certainly not be what you expect and it could be potentially disastrous.

I installed the registered version of WinDriver. Now my sample programs,which are supplied by Jungo (PCI Bus Diagnostics, Parallel Port Sample, etc.),do not work. What is the problem?

The sample programs were written with the evaluation version in mind (so that they can be distributed and used without a license during the evaluation period). You can modify their source code in order to register your license registration string from the code — as explained in FAQ #reg1.

My WD_Transfer() memory transfer routines are too slow. Can I speed them up?

You can replace the calls to WD_Transfer() with direct memory access, by utilizing the virtual user mode mapping of the base physical address for the relevant memory range, which is returned by WD_CardRegister() in: cardReg.Card.Item[i].I.Mem.dwUserDirectAddress (where ‘i’ is the index number of the memory base address in the WD_ITEMS ‘Item‘ array).
This is documented in the WinDriver User's Manuals (see the description of WD_CardRegister() in the Function Reference chapter and the Improving Performance chapter) and in Technical Documents 74 and 17. Technical document 17 also includes other suggestions on how you might improve your driver’s performance with WinDriver.

I have installed my driver on a target machine and there are some problems that don’t occur on my development machine. Can I run the DebugMonitor utility on a target machine as well, or only on the development machine?

WinDriver’s Debug Monitor utility can run on any machine (unlike the WinDriver DriverWizard utility, which is locked down to the development machine). Therefore, you can simply copy the wddebug_gui or wddebug program file from the development machine (from WinDriver/util or from /Applications on — in WinDriver versions that support this OS), to a target machine on which the WinDriver driver(s) have been installed, and run the Debug Monitor on the target. For detailed information regarding the Debug Monitor utility, refer to the WinDriver User's Manuals and to the Debug Monitor FAQ.

Kernel PlugIn FAQs

Is the Kernel PlugIn free? How do I obtain a license to use it?

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

Do I need Microsoft’s driver development kit to build a Kernel PlugIn project?

If you are using Kernel PlugIn to develop a Windows SYS driver, 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).

How many interrupts can we expect to service in one second (typical)?

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

How do I allocate locked memory in the kernel, which can be used from within the Kernel PlugIn interrupt routines?

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.

When handling my interrupts entirely in the Kernel PlugIn, can I erase the interrupt handler in the user mode?

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

Can I use the Kernel PlugIn feature to write a SYS Windows driver file?

Kernel PlugIn enables you to create an add-on *.sys/.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 Plug In feature, you must also install the WinDriver kernel module for your WinDriver version and target OS — windrvr<version>.sys/.o/.ko since WinDriver v11.9.0 (e.g., windrvr1221.sys/.o/.ko) or a renamed version of this driver.

How can I print debug statements from the Kernel PlugIn that I can view using a kernel debugger, such as WinDbg?

You can use WinDriver’s WD_DebugAdd() function (available from v5.0.3 and above) to print debug messages from your Kernel PlugIn or user-mode code to the Debug Monitor utility, and then view the messages in the Debug Monitor log. WD_DebugAdd() can be called from within any user-mode or Kernel PlugIn function, including KP_IntAtIrql().

You can also select to send the debug information from WinDriver’s Debug Monitor to a kernel debugger, as explained in Technical Document 44.

In addition, you can add calls in your Kernel PlugIn code to OS kernel functions that print directly to the kernel debugger — such as KdPrint() on Windows,
or printk() on Linux.

My PC hangs while closing my application. The code fails in WD_IntDisable(). Why is this happening?I am using the Kernel PlugIn to handle interrupts.

This might happen if you are enabling the interrupt from your Kernel PlugIn interrupt routines, and simultaneously disabling it from the user mode (using WD_IntDisable() or InterruptEnable() / WDC_IntEnable() — which call WD_IntDisable()). Since the interrupt is active (having been enabled from the Kernel PlugIn), the interrupt cannot be disabled and the PC hangs waiting for WD_IntDisable() to return.

A possible solution, is to call WD_IntDisable()/InterruptEnable()/WDC_IntEnable() as an atomic operation, so that it will disable the interrupts successfully before the Kernel PlugIn interrupt routine enables the interrupt.

When I install my Kernel PlugIn module I get errors regarding unresolved symbols.

If I write a new function in my SYS Kernel PlugIn driver, must it also be declared with __cdecl?

No. Only the callbacks used by WinDriver need to be declared as __cdecl.

Windows FAQs

What is A WDM device driver and does WinDriver support WDM?

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 Plug-and-Play Windows platforms (Windows 98 and higher, not including Windows NT 4.0). 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, which implements WinDriver’s API, is a full WDM driver.

When installing a WinDriver-based driver on a Windows XP machine, Windows displays this error:The software you are installing for this hardware has not passed Windows Logo Testing ... and may impair or destabilize the correct operation of your system ...
Is this a problem? How can I avoid such messages?

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 Certification Program (previously known as the Windows Logo Program (WLP) for Windows Hardware Quality Labs (WHQL) certification).

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

Is WinDriver digitally signed by Microsoft?
How can I digitally sign my WinDriver-based driver?

WinDriver is fully compliant with Microsoft’s Windows Certification Program (which replaced the Windows Logo Program (WLP) for Windows Hardware Quality Labs (WHQL) certification). The driver you develop with WinDriver for Windows can be submitted to Microsoft for certification and a digital signature by submitting a Windows Hardware Kit (HCK) package using the Windows Hardware Dashboard.
Many WinDriver customers have already successfully signed their WinDriver-based drivers with Microsoft.
For more information on Microsoft’s Windows Certification Program and the driver certification process, refer to to the relevant section in the WinDriver User's Manuals and to the Microsoft documentation mentioned there.
For further assistance, contact us via our Support Center.

My PCI device is not recognized by the WinDriver PCI applications on Windows. The device is functioning properly and is recognized correctly on Linux, or using v6.0.2 of WinDriver on Windows.

Set the PciCfgRwCompat registry key flag in the WinDriver driver INF file (v10.3.1 and higher) to 1 to enable the legacy PCI configuration space read/write method, as explained in Technical Document 2.

Windows CE FAQs

I am writing a CE NDIS driver. It will talk to the CE IP stack.
I need to access the NIC hardware from my driver. Can I use WinDriver?

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.

I am writing a serial port to NDIS driver for Windows CE. Can I use WinDriver?

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.

Linux FAQs

When I install my Kernel PlugIn module on Linux I get errors regarding unresolved symbols.

Make sure to install the WinDriver kernel module — windrvr<version>.o/.ko (e.g., windrvr1221.o/.ko) (or windrvr6.o/.ko / windrvr.o in earlier versions of WinDriver) — 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 Manuals for your WinDriver version and to Technical Document 62.

I am trying to allocate a kernel buffer on Linux. I can allocate a 100KBbuffer, but I cannot allocate 150KB. What should I do?

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.

CardBus FAQs

Does WinDriver support a laptop’s CardBus slot using the PCI driver?

Yes. You can use the WinDriver PCI toolkit 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 — windrvr<version>.sys (e.g., windrvr1221.sys), or windrvr6.sys / windrvr.sys / wdpnp.sys / wdusb.sys in earlier versions of WinDriver.

Parallel/Serial Port FAQs

I am using WinDriver for communicating peripherals with the parallel port. In case of ECP mode, some computers work well, but on one computer this does not work.

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.

Interrupt FAQs

I am currently seeing 25ms between an interrupt and activation of our user-mode interrupt handler. Is this the performance that I should expect with the handler in the application? I am considering moving our interrupt handler to a Kernel PlugIn to enable us to handle interrupts faster.

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.

I used the DriverWizard to generate code to handle my level-sensitive interrupt. After WD_IntWait() returns, I read the interrupt status register but it does not show me that an interrupt had occurred. This is a problem if I have multiple cards sharing an interrupt.

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 PCI User's Manual and in Technical Documents 104 and 75.

I tried to use the DriverWizard to listen to the interrupts of my PCI board, but I got the following message:WARNING!! You did not choose an Access Register for this interrupt.
If you do not want to specify a register you will have to manually change the code generated by DriverWizard.

PCI uses level sensitive interrupts, which must be acknowledged and cleared in the kernel immediately when they are received. Therefore, WinDriver requires you to define an interrupt status register, which should be read/written in order to clear the interrupt. This is a precautionary feature, because a level sensitive interrupt that is not acknowledged can hang your PC. Please refer to Technical Document 105 for a detailed explanation on how to listen to PCI interrupts with WinDriver’s DriverWizard. Also, refer to Technical Document 75 and to the WinDriver PCI User's Manual for a general explanation regarding the handling of PCI interrupts with WinDriver.

NOTE that as specified in the WinDriver documentation, in order to handle PCI interrupts correctly with WinDriver on Plug-and-Play (PnP) Windows operating systems, you must first install an INF file for the device, which registers it to work with WinDriver’s PnP driver — windrvr<version>.sys (e.g., windrvr1221.sys), or windrvr6.sys / windrvr.sys / wdpnp.sys / wdusb.sys in earlier versions of WinDriver.

Does WinDriver support Message-Signaled Interrupts (MSI)?

Yes. Beginning with version 9.1.0 WinDriver supports Message Signaled-Interrupts (MSI) and Enhanced Message-Signaled Interrupts (MSI-X) on Windows Vista and higher and Linux.
Support for additional operating systems will be added in future versions of WinDriver.

NOTE: Support for MSI/MSI-X on Windows is provided only on Windows Vista and higher, because earlier versions of Windows do not support these types of interrupt.

DMA FAQs

I am unable to lock a large memory block (more than 1MB) using WD_DMALock().
The Debug Monitor shows that Scatter/Gather lock failed.

To lock a large DMA buffer (more than 1MB) for Scatter/Gather (S/G) DMA (i.e., when the KERNEL_BUFFER_ALLOC DMA options flag is not set), using WD_DMALock() function, perform the following steps.

NOTE
When using the high-level WDC_DMASGBufLock()function(available beginning with version 7.0.0 of WinDriver), you do not need toperform similar configurations to lock a large DMA buffer; the function already handles this for you. The following steps are required only when using the low-level WD_DMALock() function.

Set the DMA_LARGE_BUFFER flag in the dwOptions field of the WD_DMA structure whoseaddress is passed as the pDma parameter of WD_DMALock() (“the WD_DMAstructure”). (Note: This flag is required only when performing Scatter/Gather DMA,as opposed to Contiguous Buffer DMA.)

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.

NOTE: By default, the WD_DMAstructure can holdinformation of up to 256 pages (= WD_DMA_PAGES, defined in WinDriver/include/windrvr.h). If you wish tolock more than 256 pages, you need to have enough memory to hold theinformation of all the pages. To allocate memory forthe additional pages’ information, 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 (using either WDC_DMASGBufLock(), or WD_DMALock() in the manner outlined above), 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 Performing DMA section in the WinDriver Implementations Issues chapter of the WinDriver pci User's Manual, and to the description of the WinDriver DMA APIs in the Function Reference chapter of the manual.

I have locked a memory buffer for DMA on Windows. Now, when I access this memory directly, using the user-mode pointer, it seems to be 5 times slower than accessing a “regular” memory buffer, allocated withmalloc(). Why?

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

When performing Contiguous Buffer DMA, you can set the DMA_ALLOW_CACHE flag in the dwOptions parameter of WDC_DMAContigBufLock, or directly in the dwOptions field of the WD_DMA structure that is passed to WD_DMALock() (when using the low-level WinDriver API), in order to allocate a cached DMA buffer. When working on Windows x86 and x86_64 platforms, it is recommended to always set this flag.
(Note: The DMA_ALLOW_CACHE flag is available beginning with version 5.2.1 of WinDriver.)

If you have allocated the memory in the user mode and then passed its address to WDC_DMASGBufLock() or to the low-level WD_DMALock() function in order to lock a Scatter/Gather DMA buffer, then calling WD_DMAUnlock() will unlock the memory buffer and it will now function like other “regular” memory in terms of access speed.

We use WinDriver PCI for 32-bit Windows, 64-bit Windows, 32-bit x86 Linux, and 64-bit x86 Linux. We have also used it for 32-bit x86 Solaris and 64-bit SPARC Solaris. This tool kit allows us to use a common driver interface for these platforms and greatly simplifies our software API architecture. Basic driver is very easy, advanced features like the kernel plug-in allow optimization of interrupt handling, etc.

Rich WadeAlta Data Technologies

The WinDriver worked out well for us. It took very little time to get the driver working. We have implemented DMA and interrupt.

Tak-kwong NgElectronics Engineer | NASA Langley Research Center

I started using the WinDriver Kit after looking at several other possibilities. All others that I looked at were targeted for Software Engineers with deep background on driver development, which for me being hardware-centric was a big obstacle. When I found the Jungo Tools I initially looked at the online video showing how to drive the kit. When I tried out the real software I was amazed that within ten minutes I had my first driver working and could interact with my custom FPGA-based board.