Driver

Contents
Getting Started with the Windows Driver Kit

What's new in driver development
Download the Windows Driver Kit (WDK)
Installing preview versions of the WDK
Other WDK downloads
Bring up guide
Developing, Testing, and Deploying Drivers
Windows Hardware Dev Center Dashboard
Device and Driver Installation
Kernel-Mode Driver Architecture Design Guide
Windows Driver Frameworks
Windows Driver Security
Windows Debugging Tools
Windows Store Device Apps
Driver Technologies
Overview of Driver Technologies
3D print devices
ACPI
Audio
Battery Drivers
Biometric Drivers
Bluetooth Drivers
Display drivers
Driver Development Tools
Getting started with Windows drivers
GNSS drivers
GPIO drivers
Hardware notifications
HID Drivers
IEEE Drivers
Imaging device drivers
Installable file system drivers
Kernel-mode driver technology
Mobile broadband
Multifunction device drivers
NetAdapterCx
Network drivers
NFC device drivers
Parallel port drivers
Partner application development
PCI drivers
PCMCIA drivers
Point of Service device drivers
Power management technologies
Print device drivers
SD card bus drivers
Sensor drivers
Serial port drivers
Smartcard device drivers
SPB drivers
Storage device drivers
Streaming media device drivers
Test Authoring and Execution Framework (TAEF)
Universal Serial Bus (USB)
Windows Device Testing Framework (WDTF)
Windows Hardware Error Architecture (WHEA)
Windows portable device drivers
Windows driver samples
What's new in driver development
12/13/2019 • 44 minutes to read • Edit Online
This section provides information about the new features and updates to Windows driver development in
Windows 10.
The following is a list of new feature highlights for driver development in Windows 10.
Windows 10, version 1903 WDK supports Visual Studio 2019
Windows Hardware Dev Center dashboard
Open publishing
Debugging Tools for Windows
Driver Verifier
Windows Driver Frameworks
Universal Windows drivers
Windows Compatible hardware development boards
Power Management Framework
System-Supplied Driver Interfaces
WPP Software Tracing
The following table shows the feature updates in Windows 10, by driver technology and version.
DRIVER 1903 1809 1803 1709 1703 1607 1507
Audio
ACPI
Biometric
Bluetooth
Buses and
Ports
Camera
Cellular
Display
Driver
security
Hardware
notifications
DRIVER 1903 1809 1803 1709 1703 1607 1507
Human
Interface
Device
(HID)
Kernel
Location
Mobile
broadband
Near Field
Communica
tion
Networking
POS
PCI
Print
Pulse Width
Modulation
Sensors
Smart Card
Storage
System-
Supplied
Driver
Interfaces
USB
WI-FI
WLAN
What's new in driver development for Windows 10

Back to Top
This section provides highlights of new features for driver development in Windows 10.
WDK supports Visual Studio 2019
The Windows Driver Kit (WDK) for Windows 10, version 1903, has been updated to support Visual Studio 2019 as
previously announced. This release of the WDK is not compatible with Visual Studio 2017 however, developers can
continue working with Visual Studio 2017 using the previous releases of the WDK, (releases 1709 thru 1809 found
here). To learn about what is new with Visual Studio 2019 please review the information here.
The following are a few items of notable changes in Visual Studio 2019 that Windows driver developers will see.
WDK GUI Driver Menu moved
In Visual Studio 2019 the WDK Driver menu has been moved to live under the Extension menu as seen below.
The WDK Driver menu in Visual Studio 2017 is located in the top menu options as seen below.
Driver Templates discoverability

In Visual Studio 2019 the WDK Driver templates will be discoverable under Project Type, Drivers. The Driver
Project Type will appear in the first official update release of Visual Studio 2019. Until then the Driver templates
can be discovered by searching for them in the search menu.
The WDK Driver templates were previously found in Visual Studio 2017 under New Projects> Visual C++>
Windows Driver as seen below.
Windows Hardware Dev Center dashboard

In Windows 10, version 1809, we added new and improved functionality in the way of Hardware APIs for
developers, IHVs, and OEMs to track and submit driver packages to the Windows hardware dashboard.
Use the shipping label REST APIs to create and manage shipping labels, the method by which you distribute your
drivers.
Manage Shipping Labels
Get shipping label data
Use the asynchronous custom report methods to access reporting data for driver errors and OEM hardware
errors. You can define reporting templates based on your needs, set a schedule and you will have data delivered to
you at regular intervals.
Schedule custom reports for your driver failure details
Open publishing
We're making the docs more community-driven. On many pages of the Windows driver documentation, you can
suggest changes directly. Look for the Contribute button in the upper right corner of a page. It looks like this:
When you click Contribute, you'll arrive at the Markdown source file for that topic in a GitHub repository. You can
click Edit and suggest changes right here.
For more details, see CONTRIBUTING.md in the repo. And thanks for taking the time to improve the docs!
Debugging Tools for Windows
This section describes the changes in the debugging tools for Windows.
Debugging in Windows 10, version 1903
New stop codes were added to allow better tracking on unique failure types in the Windows operating
system. In addition a number of existing bug check topics were expanded and updated. For more
information, see Bug Check Code Reference.
Updates to KDNET topics to improve ease of use, for example in new Setting Up KDNET Network Kernel
Debugging Automatically
Updates to IP V6 KDNET support.
New JavaScript Debugging topic
New Debugger Data Model API – A new object oriented debugger data model interface to support
debugger automation is now available using the dbgmodel.h header. The debugger data model is an
extensible object model that is central to the way in which new debugger extensions (including those in
JavaScript, NatVis, and C++) both consume information from the debugger and produce information that
can be accessed from the debugger as well as other extensions. Constructs which are written to the data
model APIs are available in the debugger's dx expression evaluator as well as from JavaScript extensions or
C++ extensions. Documentation will be available at: Overview of the Debugger Data Model C++ Interface
and the dbgmodel.h header reference topics.
IPv6 - We are adding support for IPv6 to KDNET. To make room for the larger headers required for IPv6,
we decreased the payload size of packets. As a result, we’re declaring a new version of the KDNET protocol,
so that host PCs running the latest version of the debugger can be used to debug target PCs that only
support IPv4. There is a version of WinDbg Preview available at https://aka.ms/windbgpreview that
supports IPv6. Follow the Debugging Tools for Windows blog for updates on KDNET IPv6 support and see
Setting Up KDNET Network Kernel Debugging Manually for more details.
WinDbg Preview Time Travel Debugging (TTD ) hands on lab - This lab introduces Time Travel Debugging (TTD ),
using a small sample program with a code flaw. TTD is used to debug, identify and root cause the issue.
The following is a list of new content sets for the Debugger in Windows 10, version 1709:
Debugging Using WinDbg Preview - A preview into the next generation debugger.
Time Travel Debugging - Overview - Record and replay an execution of your process.
The following table shows changes for the Debugger in Windows 10, version 1703:
NEW TOPICS UPDATED TOPICS
JavaScript Debugger Scripting dtx (Display Type - Extended Debugger Object Model
Information) command
40 undocumented stop codes in the Bug Check Code Updates to the Configuring tools.ini topic with additional
Reference options in the tools.ini file for the command line debuggers
!ioctldecode command New command capabilities in the dx (Display Debugger Object

Model Extension) command

In Windows 10, version 1607, changes to the Debugger include a new topic about Debugging a UWP app using
WinDbg, and updates to the 30 most-viewed developer bug check topics in Bug Check Code Reference.
The following is a list of new commands for the Windows Debugger in Windows 10, version 1507:
dx (Display NatVis Expression) - A new debugger command which displays object information using the
NatVis extension model.
.settings - A new command that sets, modifies, displays, loads and saves settings in the Debugger.Settings
namespace.
In Windows 10, version 1809, the following content was added:
INF AddEventProvider Directive
INF DDInstall.Events Section
The following was updated:
Early Launch AntiMalware Requirements
Kernel-Mode Code Signing Requirements
Driver Verifier
Driver verifier includes new driver validation rules for the following technologies:
New Rules for Audio Drivers
New Rules for AVStream Drivers
Four new Rules for KMDF Drivers
Three new Rules for NDIS Drivers
New Nullcheck rules Added in version 1703
Windows Driver Frameworks (WDF )
WDF in Windows 10, version 1903
In Windows 10, version 1903, the Windows Driver Framework (WDF ) includes Kernel-Mode Driver Framework
(KMDF ) version 1.29 and User-Mode Driver Framework (UMDF ) version 2.29.
For info on what's included in these framework versions, see What's New for WDF Drivers in Windows 10. To see
what was added in previous versions of WDF, see KMDF Version History and UMDF Version History.
This section describes new and updated features for Universal Windows drivers in Windows 10.
Back to Top
Universal Drivers in Windows 10, version 1809
Starting in Windows 10, version 1809, Windows supports flexible linking, which enables you to use a single binary
to target OneCore and Desktop SKUs. To enable flexible linking, use the following new SDK API:
IsApiSetImplemented
This existing topic has been enhanced to describe how to use flexible linking to comply with the U requirement of
the DCHU driver design principles:
Building for OneCore
See the latest recommendations for universal drivers in Getting started with universal drivers.
The following is a list of new features to Universal Drivers in Windows 10, version 1709:
Updating Device Firmware using Windows Update - Describes how to update a removable or in-chassis
device's firmware by using the Windows Update (WU ) service.
Reg2inf - The Driver Package INF Registry Conversion Tool (reg2inf.exe) converts a registry key and its values
or a COM .dll implementing a DLL RegisterServer routine, into a set of INF AddReg directives. These directives
are included in the driver package INF file.
The following is a list of updates to Universal Drivers in Windows 10, version 1709:
The Universal Drivers Scenario has a new COM component example
INF AddComponent Directive
Using an Extension INF file
Using a Component INF file
Universal Drivers in Windows 10
Starting in Windows 10, you can write a single driver that works on OneCoreUAP -based editions of Windows,
such as Windows 10 for desktop editions (Home, Pro, Enterprise, and Education), Windows 10 Mobile, and
Windows 10 IoT Core (IoT Core). Such a driver is called a Universal Windows driver. A Universal Windows driver
calls a subset of the interfaces that are available to a Windows driver. For information about how to build, install,
deploy, and debug a Universal Windows driver for Windows 10, see Getting Started with Universal Windows
drivers.
When you build a Universal Windows driver using Microsoft Visual Studio 2015, Visual Studio automatically
checks if the APIs that your driver calls are valid for a Universal Windows driver. You can also use the
ApiValidator.exe as a standalone tool to perform this task. The ApiValidator.exe tool is part of the Windows Driver
Kit (WDK) for Windows 10. For info, see Validating Universal Windows drivers.
Universal Windows drivers also require a special kind of INF file called a universal INF. A universal INF can use a
subset of the directives and sections available to a legacy INF file. To learn more, see Using a Universal INF File. To
see which sections and directives apply, see INF File Sections and Directives.
When you're ready, use the InfVerif tool to test your driver's INF file. In addition to reporting INF syntax problems,
the tool reports if the INF file will work with a Universal Windows driver.
You can also find information about which APIs you can call from a Universal Windows driver. This information is
located in the Requirements block at the bottom of driver reference pages.
For example, you'll see a listing similar to this one that tells you if a given DDI is Universal.
For more info, see Target platform on driver reference pages.

Windows compatible hardware development boards
Windows is now supported on more affordable boards such as the Raspberry Pi 2. Become a part of our early
adopter community and load Windows on that board. For more information, see Windows compatible hardware
development boards.
Power Management Framework
The power management framework (PoFx) enables a driver to define one or more sets of individually adjustable
performance states for individual components within a device. The driver can use performance states to throttle a
component's workload to provide just enough performance for its current needs. For more information, see
Component-Level Performance State Management.
Windows 10, version 1903 includes support for the Directed Power Management Framework (DFx). Related
reference documentation includes the following:
PO_FX_DEVICE_V3
PO_FX_DIRECTED_POWER_DOWN_CALLBACK callback function
PO_FX_DIRECTED_POWER_UP_CALLBACK callback function
PoFxCompleteDirectedPowerDown function
For information about testing for DFx, please see the following pages:
Directed FX Single Device Test
Directed FX System Verification Test
PwrTest DirectedFx Scenario
WPP Software Tracing
WPP Software Tracing introduces a new feature: Inflight Trace Recorder. If the driver enables WPP tracing and
WPP Recorder, trace logging is turned on automatically and you can easily view messages without starting or
stopping trace sessions. For more fine tuned control over the log, WPP Recorder allows a KMDF driver to create
and manage custom buffers.
WPP Recorder for logging traces
WppRecorderLogGetDefault
WppRecorderLogCreate (KMDF only)
WppRecorderDumpLiveDriverData
What's new in Windows 10, version 1903 (latest)

This section describes new features and updates for driver development in Windows 10, version 1903 (Windows
10 April 2019 Update).
Back to Top
Audio
The following is a list of new and updated Audio features in Windows 10, version 1903:
New reference topics on the Audio OEM Adapter used for Voice Activation in the new
eventdetectoroemadapter.h header.
New Far Field Audio information:
PKEY_Devices_AudioDevice_Microphone_IsFarField
KSPROPSETID_InterleavedAudio
KSPROPERTY_INTERLEAVEDAUDIO_FORMATINFORMATION
New jack description information in USB Audio 2.0 Drivers.
Camera
New Camera driver documentation and features added in Windows 10, version 1903 include:
New IR Torch extended property control to set an IR camera's infrared torch power level and duty cycle.
New KSCATEGORY_NETWORK_CAMERA device.
New and updated USB Video Class (UVC ) 1.5 extension documentation for the following control selectors:
MSXU_CONTROL_FACE_AUTHENTICATION
MSXU_CONTROL_METADATA
MSUX_CONTROL_IR_TORCH
Display
Updates to Display driver development in Windows 10, version 1903 include the following:
Super Wet Ink New DDIs were added to enable front buffer rendering. See
D3DWDDM2_6DDI_SCANOUT_FLAGS and
PFND3DWDDM2_6DDI_PREPARE_SCANOUT_TRANSFORMATION.
Variable Rate Shading Enables allocation of rendering performance/power at varying rates across
rendered images. See PFND3D12DDI_RS_SET_SHADING_RATE_0062 and
D3D12DDI_SHADING_RATE_0062.
Collect Diagnostic Info Allows the OS to collect a private data from drivers for graphics adapters which
consist of both rendering and display functions. See DXGKDDI_COLLECTDIAGNOSTICINFO.
Background Processing Allows user mode drivers to express desired threading behavior, and the runtime
to control/monitor it. User mode drivers would spin up background threads and assign the threads as low a
priority as possible, and rely on the NT scheduler to ensure these threads don’t disrupt the critical-path
threads, generally with success. See PFND3D12DDI_QUEUEPROCESSINGWORK_CB_0062.
Driver Hot Update Reduce server downtime as much as possible when an OS component needs to be
updated. See DXGKDDI_SAVEMEMORYFORHOTUPDATE and
DXGKDDI_RESTOREMEMORYFORHOTUPDATE.
Networking
NetAdapterCx
In the NetAdapter WDF class extension (NetAdapterCx), Net ring buffers have been replaced by Net rings, which
have a new interface for sending and receiving network data using net ring iterators. The following is a list of new
topics:
Introduction to net rings
Sending network data with net rings with a new animation that illustrates how to send data
Receiving network data with net rings with a new animation that illustrates how to receive data
Canceling network data with net rings
New headers that support this feature include the following:
Ring.h
Ringcollection.h
Netringiterator.h
The following is a list of NetAdapterCx content updates:
Default adapter objects have been removed in favor of a single adapter object type. The following topics
have been updated accordingly:
Summary of NetAdapterCx objects
Device and adapter initialization
Hardware offload and packet extension DDIs have been reorganized into new headers:
Checksum.h
Checksumtypes.h
Extension.h
Lso.h
Lsotypes.h
Rsc.h
Rsctypes.h
Fundamental networking data structures, packets and fragments, have been updated and put into new
headers:
Packet.h
Fragment.h
Overhauled Transmit and receive queues topic to include callback samples and major operations for packet
queues.
Mobile operator scenarios
New Mobile Plans content for mobile operators to sell plans to customers directly on Windows 10 devices,
through the Mobile Plans app:
Mobile Plans
Mobile broadband
The following features were added to Mobile broadband in Windows 10, version 1903:
New SIM card (UICC ) file/application system access feature
New Cellular Time Information (NITZ ) feature.
New modem logging with DSS feature.
New 5G data class support feature.
Print
New Print driver documentation and features added in Windows 10, version 1903 include:
New USB print IOCTLs:
IOCTL_USBPRINT_GET_INTERFACE_TYPE
IOCTL_USBPRINT_GET_PROTOCOL
IOCTL_USBPRINT_SET_PROTOCOL
New fpRegeneratePrintDeviceCapabilities PRINTPROVIDER structure member and updated
documentation.
Sensors
New features in sensor driver development in Windows 10, version 1903 include a MALT (Microsoft Ambient
Light Tool) tool for testing and calibrating screen brightness.
There were also updates to the Ambient Color OEM whitepaper.
Storage
The following Storage features were added in Windows 10, version 1903:
New Storport APIs for logging device failure and hardware protocol errors in ETW events and to query for
platform D3 desired behavior
New API to set the properties of a storage device or adapter
For file systems, new DDIs were added to support retrieving extended attributes (EA) information upon create
completion, allowing mini-filters to alter the ECP payload to change what higher filters see
Windows Hardware Error Architecture (WHEA )
Windows 10, version 1903 includes a simplified interface to WHEA. For more info, see the following pages:
WheaAddErrorSourceDeviceDriver
WheaReportHwErrorDeviceDriver
WheaRemoveErrorSourceDeviceDriver
WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER
WHEA_ERROR_SOURCE_READY_DEVICE_DRIVER
WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER
WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER
Wi-fi
New Wi-fi driver development documentation and features include:
New Fine Timing Measurement (FTM ) feature
New WPA3-SAE Authentication feature
New Multiband Operation (MBO ) support to improve roaming performance in enterprise scenarios
New beacon report offloading support
For OID commands, NDIS status indications, and TLVs for these new features, see WDI doc change history
The following topics were updated for Windows 10, version 1903:
WDI_AUTH_ALGORITHM - added support for WPA3-SAE authentication
OID_WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME and
OID_WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME - added additional validation of outgoing Point to
Point (P2P ) action frames
What's new in Windows 10, version 1809

10 October 2018 Update).
Back to Top
Audio
Documentation on the new sidebandaudio and usbsidebandaudio headers is now available.
Bluetooth
HCI_VS_MSFT_Read_Supported_Features has been updated to include a new flag for secure simple pairing
process. See, Microsoft-defined Bluetooth HCI commands and events.
New QDID for Windows 10, version 1809 is available here: 108589. For a complete list of QD ID for all
releases, see Bluetooth.
Display
Updates to Display driver development in Windows 10, version 1809 include the following:
Raytracing New Direct3D DDI's were created in parallel of Direct3D API's, in order to support hardware-
accelerated raytracing. Example DDIs include:
PFND3D12DDI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_0054,
PFND3D12DDI_COPY_RAYTRACING_ACCELERATION_STRUCTURE_0054. For more info about
raytracing, see Announcing Microsoft DirectX Raytracing.
Universal Driver Requirements WDDM 2.5 drivers will need to ensure their DirectX11 UMD, DirectX12
UMD, KMDs, and any other DLL loaded by these components, adhere to the Universal API.
SRV -Only Tiled Resource Tier 3 In Windows 10, version 1809, Tiled Resource Tier 3 capabilities can be
supported less-orthogonally by GPUs. Direct3D12 now supports sparse volume textures without requiring
unordered-access and render-target operations. SRV -Only Tiled Resource Tier 3 is a conceptual tier that fits
between Tier 2 and Tier 3. Hardware support is optional, just like orthogonal Tiled Resource Tier 3 support
currently is. But, supporting SRV -Only Tiled Resource Tier 3 is a super-set tier that requires support for
Tiled Resource Tier 2.
Drivers that already advertise support for orthogonal Tiled Resource Tier 3 merely have to update their
drivers to support the latest “options caps” DDI structure version. The runtime will advertise SRV -Only
Tiled Resource Tier 3 support to applications for any hardware that already supports orthogonal Tiled
Resource Tier 3.
Render Pass The Render Pass feature was added to:
Allow new APIs to be run on existing drivers.
Allow user mode drivers to choose optimal rendering path without heavy CPU penalty.
Meta-commands A Meta-command is Direct3D12 object that represents an IHV -accelerated algorithm.
It’s an opaque reference to a command generator implemented by the driver. Meta-command updates
include Descriptor Table Binding and Texture binding. See
D3D12DDI_META_COMMAND_PARAMETER_TYPE and
D3D12DDIARG_META_COMMAND_PARAMETER_DESC.
Enable Compute Algorithms to use Texture Resources (swizzled memory)
Enable Graphics Pipeline Algorithms
HDR Brightness Compensation A new SDR brightness boost was introduced to raise the reference white
of SDR content to the user-desired value, allowing SDR content to be reproduced to a typical 200-240 nits,
which is equivalent to what users have expected for SDR displays. SDR brightness boost affects overall
Brightness3 behavior in two ways:
1. This boost is applied pre-blend only on SDR content. HDR content is not affected. Meanwhile, for
most laptop/brightness3 scenarios, users expect all content (SDR and HDR ) to be adjusted.
2. When the Brightness3 stack in the OS determines the desired nits value, it is not aware of the already
applied SDR boost.
The driver must then apply a compensation to the desired nits value coming from Brightness3 DDIs
for HDR. Since Graphics drivers (and downstream TCON etc.) will be modifying the pixel values of
the content to get desired nits value, there should also be a compensation applied to the HDR content
metadata as provided by the applications via D3DDDI_HDR_METADATA_HDR10 or OS defaults via
DxgkDdiSetTargetAdjustedColorimetry. Since Graphics driver (TCONs) are responsible for
modifying the pixel data, it is the driver’s responsibility to compensate the HDR content metadata.
HDR Pixel Format Support This kernel mode device driver interface (DDI) change is part of WDDM 2.5
to expose new capabilities to be reported by driver/device, providing information regarding the HDR
functionality supported by the driver/device.
Currently, OS determines if the driver/device supports HDR based on the HighColorSpace bit of the
DXGK_MONITORLINKINFO_CAPABILITIES structure as read from DdiUpdateMonitorLinkInfo. The
HighColorSpace bit gives a combination of driver/link/monitor capability to run in HDR mode.
The HDR capabilities reporting by the driver now includes a Driver/Device level capabilities, which will let
OS know if the Driver/Device supports true HDR (i.e. FP16HDR ), or only supports a limited form of HDR
(i.e. ARGB10HDR ), as defined below:
FP16HDR: Driver/device can take FP16 pixel format surfaces with scRGB/CCCS colorspace and
apply PQ/2084 encoding and BT.2020 primaries during scanout pipeline to convert output signal to
HDR10.
ARGB10HDR: Driver/device can take ARGB10 pixel format surfaces which are already PQ/2084
encoded and scan out HDR10 signal. Driver/device can’t handle FP16HDR as defined above or
cannot handle the extended numeric range of scRGB FP16.
Graphics drivers can only report support for either FP16HDR or ARGB10HDR as they are not really
superset/subset configurations and OS will fail the Start Adapter if both are reported as supported at
the same time. See DXGK_MONITORLINKINFO_CAPABILITIES and
_DXGK_DISPLAY_DRIVERCAPS_EXTENSION.
SDR White Level A kernel mode device driver interface change includes adding new parameters to
existing DDIs to let the Graphics drivers know the “SDR white level” value that is being applied by the OS
compositor for all the SDR content, for a display which is running in HDR mode. See
_DXGK_COLORIMETRY.
Windows kernel
Several new APIs have been added in the core kernel:
RtlQueryRegistryValueWithFallback function: Querying the registry value entry by using a fallback handle in
absence of a primary handle.
PsGetSiloContainerId function and PsGetThreadServerSilo function
New information classes added to: _FILE_INFORMATION_CLASS
FileLinkInformationExBypassAccessCheck
FileCaseSensitiveInformationForceAccessCheck
FileStorageReserveIdInformation
FileLinkInformationEx
Extended version of NtCreateSection added NtCreateSectionEx function to indicate that this is actually an AWE
section.
New Ex macros grant direct access to actual push lock APIs exported by Ntoskernel.
ExAcquirePushLockExclusive macro
ExAcquirePushLockShared macro
ExInitializePushLock function
ExReleasePushLockExclusive macro
ExReleasePushLockShared macro
KzLowerIrql and KzRaiseIrql were moved to a supported extern forceinline for kernel components targeting
Windows 8 and later versions, instead of relying on the forwarders to instantiate a special case of the inline
functions.
Flattening Portal Bridge (FPB ) for PCI is now supported. For more information, see the Official Specification.
The new APIs (PCI_FPB*) are declared in Ntddk.h.
Networking
NetAdapterCx
New INF files for NetAdapterCx client drivers topic.
Transmit and receive queues have been consolidated into one object type called a packet queue, to simplify
the API surface. A new section called Polling model has been added to the Transmit and receive queues
topic.
Hardware offloads have been added to NetAdapterCx, which also automates the registration of associated
packet extensions for client drivers.
Network interfaces are now decoupled from the driver's WDF device object. The
EvtNetAdapterSetCapabilities callback function was removed to support this. NetAdapterCx client drivers
can now have multiple network interfaces, including a default one.
Topics updated to support network interface/device object decoupling include the following:
Summary of NetAdapterCx objects
Device and adapter initialization
Power-up sequence for a NetAdapterCx client driver
Power-down sequence for a NetAdapterCx client driver
DDIs supporting NetAdapterCx Receive side scaling (RSS ) have been simplified.
Packet context token helper macros have been removed.
NDIS
Receive side scaling version 2 (RSSv2) has been updated to version 1.01.
Mobile broadband
New OID and DDIs to support multiple packet data protocol (MPDP ) interfaces for MBB devices.
New Device-based Reset and Recovery feature for more robust reset recovery for MBB devices and drivers.
Mobile Broadband WDF class extension (MBBCx )
MBBCx power management methods have been simplified.
Though preview content for MBBCx was available in Windows 10, version 1803, MBBCx now ships in the
Windows 10, version 1809 version of the WDK.
Mobile operators
The AutoConnectOrder setting is now supported in desktop COSA.
Sensors
Support for auto Brightness feature:
The PKEY_SensorData_IsValid data field has been added to support auto brightness in sensors.
See Light sensor data fields for more info.
USB
New feature for USB Type-C driver developers:
If your hardware is UCSI compliant and requires communication over a non-ACPI transport, you can utilize the
new class extension — (UcmUcsiCx.sys). This implements the UCSI specification in a transport agnostic way. With
minimal amount of code, your driver, which is a client to UcmUcsiCx, can communicate with the USB Type-C
hardware over non-ACPI transport. This topic describes the services provided by the UCSI class extension and the
expected behavior of the client driver.
Write a UCSI client driver
UcmUcsiCx class extensions reference
UcmUcsiCx client driver sample
New feature for USB Type-C driver developers that allows you to monitor the activities of USB Type-C
connectors and/or get involved in policy decisions on USB Type-C connectors.
For example, control their device’s charging based on thermal conditions, so that the device won’t be overheated.
Write a USB Type-C Policy Manager client driver
New APIs are available in Usbpmapi.h
New versions of the class extensions available for emulated USB devices (UDE ) -- 1.1 and USB host
controller (Ucx) 1.5:
Emulated devices now support better reset recovery through function (FLDR ) and platform (PLDR ) resets. The
client driver can now inform the system that the device needs a reset and the type of reset: function or platform.
UdecxWdfDeviceNeedsReset function
The host controller can also opt for FLDR and PLDR resets through:
EVT_UCX_USBDEVICE_DISABLE
Wi-fi
The WLAN device driver interface (WDI) spec has been updated to version 1.1.7.
Added support for the latest 802.11ax PHY type for WDI drivers.
Added support for unsolicited device service indications.

10 April 2018 Update).
Back to Top
ACPI
Windows 10, version 1803 includes updates to ACPI DDIs to support platform capabilities and physical device
location.
Audio
The voice activation topic was updated to include additional information on APO requirements.
Bluetooth
Windows 10, version 1803 introduces support for Swift Pair. Users no longer need to navigate the Settings App
and find their peripheral to pair. Windows can now do this for them by popping a notification when a new
peripheral is nearby and ready. There are two sets of requirements to ensure your peripheral works with Swift Pair.
One set is for the peripheral’s behavior, and another for the structure and values in a Microsoft defined vendor
advertisement section. For more information, see:
Bluetooth Swift Pair
Bluetooth Features and Recommendations
Windows 10, version 1803 supports Bluetooth version 5.0. For information about profile support, see Bluetooth
Version and Profile Support in Windows 10.
Camera
Updates to Camera driver development include:
DShow (DirectShow ) Bridge implementation guidance for UVC devices - Implementation guidance for
configuring DShow Bridge for cameras and devices that comply with the USB Video Class (UVC ) specification.
The platform uses Microsoft OS Descriptors from the USB bus standard to configure DShow Bridge. The
Extended Properties OS Descriptors are an extension of USB standard descriptors and are used by USB devices
to return Windows specific device properties that are not enabled through standard specifications.
360 camera video capture - Provides support for 360 camera preview, capture, and record with existing
MediaCapture APIs. This enables the platform to expose spherical frame sources (for example, equirectangular
frames ), enabling apps to detect and handle 360 video camera streams as well as to provide a 360 capture
experience.
Display
The following are updates to Display driver development in Windows 10, version 1803:
Indirect Display UMDF class extension - The Indirect Display driver can pass the SRM to the rendering
GPU and have a mechanism to query the SRM version being used.
IOMMU hardware-based GPU isolation support - Increases security by restricting GPU access to
system memory.
GPU paravirtualization support - Enables display drivers to provide rendering capabilities to Hyper-V
virtualized environments.
Brightness - A new brightness interface to support multiple displays that can be set to calibrated nit-based
brightness levels.
D3D11 bitstream encryption - Additional GUIDS and parameters to D3D11 to support exposing CENC,
CENS, CBC1, and CBCS with 8 or 16 byte initialization vectors.
D3D11 and D3D12 video decode histogram - A luminance histogram allows the media team to leverage
fixed function hardware for histogram to improve tone mapping quality for HDR/EDR scenarios. Fixed
function hardware is useful when GPU is already saturated in these scenarios and to enable parallel
processing. This feature is optional and should only be implemented if fixed function hardware is available.
This feature should not be implemented with 3D or Compute.
D3D12 video decode now supports Decode Tier II, indicating driver supports Array of Textures that
enable applications to amortize allocation cost and reduce peak memory usage during resolution change.
Tiled resource tier and LDA atomics - A new cross node sharing tier to add support for atomic shader
instructions working across linked adapter (LDA) nodes. This improves ISVs ability to implement multiple
GPU rendering techniques like split frame rendering (SFR ) and clearly advances the capabilities over what is
possible in D3D11.
GPU dithering support - Drivers can report the ability to perform dithering on the wire signal for a given
timing mode. This allows the OS to explicitly request dithering in scenarios where a higher effective bit
depth is needed than is physically available on the monitor link, for example for HDR10 over HDMI 2.0.
Post-processing color enhancement override - Adds the ability for the OS to request that the driver
temporarily disable any post-processing that enhances or alters display colors. This is to support scenarios
where specific applications want to enforce colorimetrically accurate color behavior on the display, and
safely coexist with OEM or IHV -proprietary display color enhancements.
Direct3D12 and Video - New API and DDI to provide access to the following capabilities:
Hardware accelerated video decoding
Content Protection
Video processing
DisplayID - A new DDI, designed to allow the VESA’s DisplayID descriptor to be queried from a display
controlled by a graphics adapter and shall support DisplayID v1.3 and DisplayID v2.0. The DDI is an
extension of existing DxgkDdiQueryAdapterInfo DDI and shall be supported by all drivers with
DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3, including kernel
mode display only drivers and indirect display drivers.
GPU performance data - Extensions to DdiQueryAdapterInfo will expose information such as
temperature, fan speed, clock speeds for engines and memory, memory bandwidth, power draw, and
voltages
Miscellaneous - A new SupportContextlessPresent driver cap to help IHV onboard new driver.
Improvements to External/Removable GPU support in the OS. As a first step to add better support, Dxgkrnl
needs to determine if a GPU is “detachable”, i.e. hot-pluggable. For RS4 we would like to leverage the
driver’s knowledge about this instead of building our own infrastructure. For this purpose, we are adding a
“Detachable” bit to DXGK_ DRIVERCAPS struct. Driver will set this bit during adapter initialization if the
adapter is hot-pluggable.
Display Diagnostics - Kernel mode device driver interface (DDI) changes to allow the driver for a display
controller to report diagnostic events to the OS. This provides a channel through which the driver can log
events which would otherwise be invisible to the OS as the events are not a response to an OS request or
something the OS needs to react to.
Shared graphics power components - Allows non-graphics drivers to participate in the power
management of a graphics device. A non-graphics driver will use a driver interface to manage one or more
of these shared power components in coordination with the graphics driver.
Shared texture improvements - Includes increasing the types of textures that can be shared across
processes and D3D devices. This design enables the frame server OS component to support monochrome
with minimal memory copying.
Driver security
Updates to Windows Driver Security Guidance and the Driver security checklist, which provides a driver security
checklist for driver developers.
Windows kernel
This section describes the new and updated features for Windows kernel driver development in Windows 10,
version 1803.
A set of new APIs has been added to the kit to enable third parties to create their own KDNET extensibility
modules or KdSerial transport layers. For sample code, see “Kernel Transport Samples” (ddk\samples\kdserial and
ddk\samples\kdnet) in the Debuggers folder.
Support was added to provide drivers with a sanctioned location (that the operating system knows about) where
they can store file state. With this approach, the system can associate files in that location with a device or driver.
There are distinct locations to store file states specific to the internals of a driver and specific to a device. For drivers
that have file state, you can decide if the state written to disk is:
Driver state (IoGetDriverDirectory): global to the driver that might be controlling multiple devices), or
Device state (IoGetDeviceDirectory): specific to the driver-controlled single device and other devices might
have different values for similar state.
Function drivers (FDO ) can now negotiate additional power when their respective PCIe devices are in a D3Cold
state. This includes:
Auxiliary power requirement D3COLD_REQUEST_AUX_POWER.
Core power rail D3COLD_REQUEST_CORE_POWER_RAIL.
Requirement for a fixed delay time between the message is received at the PCI Express Downstream Port and
the time the platform asserts PERST# to the slot during the corresponding endpoint’s or PCI Express Upstream
Port’s transition to D3cold while the system is in an ACPI operational state. See
D3COLD_REQUEST_PERST_DELAY.
NT services and kernel-mode and user-mode drivers can raise a custom trigger for a device by using the
RtlRaiseCustomSystemEventTrigger function. A custom trigger, owned by the driver developer, notifies system
event broker to start an associated background task with it, which is identified by a custom trigger identifier.
You can now register for active session change notification and get a callback when the notification is fired. As part
of this notification, some data is also shared with the caller. This associated data is delivered via the
PO_SPR_ACTIVE_SESSION_DATA structure.
Networking
This section outlines new features and improvements for Windows Networking driver development in Windows
10, version 1803.
NDIS and NetAdapterCx
Updates to NDIS include:
Receive side scaling V2 has been updated with further details about steering parameters
The Synchronous OID interface now supports NDIS light weight filter drivers
The following topics are new for the Network Adapter WDF class extension (NetAdapterCx):
Introduction to NetAdapterCx 1.2
Packet descriptors and extensions
Network data buffer management
NetAdapterCx receive side scaling (RSS )
Additionally, new topics are available for a preview -only feature, the Mobile Broadband class extension (MBBCx),
which uses the NetAdapterCx model for mobile broadband connectivity.
Mobile Broadband Class Extension (MBBCx)
Writing an MBBCx client driver
MBBCx API reference
Mobile broadband
In mobile broadband, a new topic detailing MB low level UICC access is available.
Mobile operators
New Hotspot and AppID settings are now a part of desktop COSA. Mobile operators are strongly encouraged to
transition from broadband app experience apps with Sysdev metadata packages to MO UWP Apps and the COSA
database.
PCIe
New ACPI _DSD methods have been added to support these Modern Standby and PCI hot plug scenarios:
Directed Deepest Runtime Idle Power State (DDRIPS ) support on PCIe Root Ports
Identifying PCIe Root Ports supporting hot plug in D3
Identifying externally exposed PCIe Root Ports
For information, see ACPI Interface: Device Specific Data (_DSD ) for PCIe Root Ports.
Sensors
The SENSOR_CONNECTION_TYPES enumeration was added to clarify connection type properties.
USB
New APIs were added to simulate detach for shared connectors. If a USB device is attached to a host or has shared
connector while the stack is being removed while the device is attached to a host or has shared connectors, you can
simulate a detach event. At this point all attach/detach notification mechanisms are disabled. For more information,
see UfxDeviceNotifyFinalExit function.
Wi-fi
Updates to Wi-fi driver development include a new TLV for the Nic Auto Power Saver (NAPS ) advanced power
management feature and updates to the platform level device recovery service (PLDR ).

This section describes new features and updates for driver development in Windows 10, version 1709.
Back to Top
Audio
The following is a list of updates to Windows Audio driver development in Windows 10, version 1709:
New Configure and query audio device modules
Extensive updates to voice activation
More details on chained and keyword only activation
A new glossary of terms
Additional information on training and recognition, such as pin and audio format information
An updated keyword system overview
Updated information on wake on voice
ACPI
The following is a list of new Advanced Configuration and Power Interface (ACPI) DDIs to support input/output
buffers.
ACPI_EVAL_INPUT_BUFFER_COMPLEX_V1
ACPI_EVAL_INPUT_BUFFER_COMPLEX_V1_EX
ACPI_EVAL_INPUT_BUFFER_COMPLEX_V2
ACPI_EVAL_INPUT_BUFFER_COMPLEX_V2_EX
ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER_V1
ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER_V2
ACPI_EVAL_INPUT_BUFFER_SIMPLE_INTEGER_V2_EX
ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING_V1
ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING_V1_EX
ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING_V2
ACPI_EVAL_INPUT_BUFFER_SIMPLE_STRING_V2_EX
ACPI_EVAL_INPUT_BUFFER_V1
ACPI_EVAL_INPUT_BUFFER_V1_EX
ACPI_EVAL_INPUT_BUFFER_V2
ACPI_EVAL_INPUT_BUFFER_V2_EX
ACPI_EVAL_OUTPUT_BUFFER_V1
ACPI_EVAL_OUTPUT_BUFFER_V2
ACPI_METHOD_ARGUMENT_V1
ACPI_METHOD_ARGUMENT_V2
GIC_ITS
Biometric
There are new signing requirements for Windows Biometric Drivers. For more information, see Signing WBDI
Drivers.
Display
The following is a list of new features for Windows Display driver development in Windows 10, version 1709.
Display ColorSpace Transform DDIs provide additional control over color space transforms applied in the post-
composition display pipeline.
The D3D12 Copy Queue Timestamp Queries feature will allow applications to issue timestamp queries on
COPY command lists/queues. These timestamps are specified to function identically to timestamps on other
engines.
Enhanced Video integration into Direct3D12 Runtime through:
1. Hardware accelerated video decoding
2. Content protection
3. Video processing
In Windows 10, version 1709, there is support for hardware-agnostic support of notification components such as
LEDs and vibration mechanisms. For more information, see:
Hardware notifications support
Hardware notifications reference
Windows kernel
In Windows 10, version 1709, several new routines to the Windows Kernel for drivers have been added.
ExGetFirmwareType and ExIsSoftBoot – Executive library support routines.
PsSetLoadImageNotifyRoutineEx – An extended image notify routine for all executable images, including
images that have a different architecture from the native architecture of the operating system.
MmMapMdl – A memory manager routine for mapping physical pages described by a memory descriptor
list (MDL ) into the system virtual address space.
PoFxSetTargetDripsDevicePowerState – A PoFx routine to notify the power manager of the device's target
device power state for DRIPS.
The following is a list of new options for the ZwSetInformationThread routine, that are related to process
policies:
PROCESS_MITIGATION_CHILD_PROCESS_POLICY
PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY
PROCESS_READWRITEVM_LOGGING_INFORMATION
PsGetServerSiloActiveConsoleId and PsGetParentSilo – New Silo APIs to get information about server
silos that are created and destroyed on a machine.
The following is a list of new RTL functions for using correlation vector to reference events and the
generated logs for diagnostic purposes.
CORRELATION_VECTOR
RtlExtendCorrelationVector
RtlIncrementCorrelationVector
RtlInitializeCorrelationVector
RtlValidateCorrelationVector
Mobile broadband
The following is a list of new features for Windows Mobile Broadband and Mobile Operator Scenarios for driver
development in Windows 10, version 1709:
UICC reset and modem reset
Protocol Configuration Operations (PCO )
Base stations information query
eSIM and MBIM ReadyState guidance
In Windows 10, version 1709, the desktop COSA documentation was updated to include new branding-related
fields. See the list of deprecated features for other changes to Mobile Operator Scenarios.
Networking
This section outlines new features and improvements for Windows Networking driver development in Windows
10, version 1709.
The following is a list of new and updated features for NDIS:
Introduction to NetAdapterCx 1.1, which includes new NewAdapterCx features:
More packet context options
Finer link state control
Improved receive buffer management and performance
General performance improvements
New Synchronous OID request interface in NDIS 6.80
New Receive Side Scaling Version 2 (RSSv2) in NDIS 6.80
Introduction to NDIS 6.80
Porting NDIS 6.x drivers to NDIS 6.80
Virtualized PCI
There are new programming interfaces for writing a Physical Function driver for devices that conform to the PCI
Express Single-Root I/O Virtualization (SR -IOV ) specification. The interfaces are declared in Pcivirt.h. For more
information, see PCI virtualization.
Pulse Width Modulation (PWM ) Controllers
In Windows 10, version 1709, to provide access to a Pulse width modulation (PWM ) controller that is part of the
SoC and memory-mapped to the SoC address space, you need to write a kernel-mode driver. For more
information, see PWM driver for an on-SoC PWM module.
To parse and validate pin paths and extract the pin number, kernel mode drivers should use PwmParsePinPath.
An app can send requests to the controller driver by sending PWM IOCTLs requests.
Storage and File Systems
In File Systems and Storage, the ufs.h header was added in Windows 10, version 1709 to provide additional
support to Universal Flash Storage.
Posix updates include new functions delete and rename.
The following is a list of headers that were updated in Windows 10, version 1709:
ata.h
fltKernel.h
minitape.h
ntddscsi.h
ntddstor.h
ntddvol.h
ntifs.h
scsi.h
storport.h
USB
This section describes the new features for USB in Windows 10, version 1709.
Media Agnostic USB (MA-USB) protocol
The USB driver stack can send USB packets over non-USB physical mediums such as Wi-Fi by using the Media
Agnostic USB (MA-USB ) protocol. To implement this feature, new programming interfaces have been released.
The new DDIs allow the driver to determine the delays associated with the
_URB_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS. That information can be retrieved by building a new URB
request. For information about this new feature, see the following topics:
USB client drivers for Media-Agnostic (MA-USB )
_URB_GET_ISOCH_PIPE_TRANSFER_PATH_DELAYS
USB Request Blocks (URBs)
To support MA-USB, the host controller driver must provide the transport characteristics by implementing specific
callback functions. The following table shows the callback functions and structures that support MA-USB.
CALLBACK FUNCTIONS STRUCTURES
EVT_UCX_USBDEVICE_GET_CHARACTERISTIC UCX_ENDPOINT_ISOCH_TRANSFER_PATH_DELAYS
EVT_UCX_USBDEVICE_RESUME UCX_CONTROLLER_ENDPOINT_CHARACTERISTIC_PRIORITY
EVT_UCX_USBDEVICE_SUSPEND UCX_ENDPOINT_CHARACTERISTIC
EVT_UCX_ENDPOINT_GET_ISOCH_TRANSFER_PATH_DELAYS UCX_ENDPOINT_CHARACTERISTIC_TYPE
EVT_UCX_ENDPOINT_SET_CHARACTERISTIC UCX_ENDPOINT_ISOCH_TRANSFER_PATH_DELAYS
Synchronized system QPC with USB frame and microframes

There are new programming interfaces that retrieve the system query performance counter (QPC ) value
synchronized with the frame and microframe.
This information is retrieved only when the caller enables the feature in the host controller. To enable the feature, a
host controller driver must implement the following callback functions.
EVT_UCX_CONTROLLER_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC
EVT_UCX_CONTROLLER_START_TRACKING_FOR_TIME_SYNC
EVT_UCX_CONTROLLER_STOP_TRACKING_FOR_TIME_SYNC
An application can use these APIs to enable/disable the feature and retrieve the information:
WinUsb_GetCurrentFrameNumberAndQpc
WinUsb_StartTrackingForTimeSync
WinUsb_StopTrackingForTimeSync
Other drivers can send these IOCTL requests to enable/disable the feature and retrieve the information:
IOCTL_USB_GET_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC
IOCTL_USB_START_TRACKING_FOR_TIME_SYNC
IOCTL_USB_STOP_TRACKING_FOR_TIME_SYNC
Here are the supporting structures for synchronized system OPC with USB frame and microframes:
USB_START_TRACKING_FOR_TIME_SYNC_INFORMATION
USB_STOP_TRACKING_FOR_TIME_SYNC_INFORMATION
USB_FRAME_NUMBER_AND_QPC_FOR_TIME_SYNC_INFORMATION
IOCTL_UCMTCPCI_PORT_CONTROLLER_DISPLAYPORT_DISPLAY_OUT_STATUS_CHANGED
The IOCTL_UCMTCPCI_PORT_CONTROLLER_DISPLAYPORT_DISPLAY_OUT_STATUS_CHANGED request is a
new request in USB Type-C Port Controller Interface framework extension. This request notifies the client driver
that the display out status of the DisplayPort connection has changed.
Here are the structures that support the
IOCTL_UCMTCPCI_PORT_CONTROLLER_DISPLAYPORT_DISPLAY_OUT_STATUS_CHANGED request:
UCMTCPCI_PORT_CONTROLLER_DISPLAYPORT_DISPLAY_OUT_STATUS_CHANGED_IN_PARAMS
UCMTCPCI_PORT_CONTROLLER_DISPLAYPORT_DISPLAY_OUT_STATUS
This section describes new and improved features for driver development in Windows 10, version 1703.
Back to Top
Audio
The following is a list of new topics for Audio driver development in Windows 10, version 1703:
Implementing Audio Module Communication - Describes the support for communication from Universal
Windows Platform (UWP ) apps to kernel mode audio device drivers.
New DDIs and properties reference topics to support APO Module Communications discovery:
KSPROPSETID_AudioModule - A new KS Property Set that defines three properties specific to audio
modules.
KSPROPERTY_AUDIOMODULE_COMMAND property - Allows Audio Module clients to send custom
commands to query and set parameters on Audio Modules.
IPortClsNotifications - New Port Class Notifications that provide notification helpers to miniports, to
support audio module communication.
Bluetooth
The following is a list of updates to Bluetooth in Windows 10 version 1703:
Hands-Free Profile (HFP ) 1.6 specification with Wideband speech on Windows 10 for desktop editions.
Support for Call Control APIs on Windows 10 for desktop editions.
Support for GATT Server, Bluetooth LE Peripheral and non-paired support for Bluetooth LE. See our developer
post for more details.
For more information about what's new for Bluetooth, see Bluetooth and Bluetooth LE pre-pairing.
Camera
The following is a list of updates to Camera driver development in Windows 10, version 1703:
USB Video Class (UVC ) driver implementation guide
Microsoft extensions to USB Video Class 1.5 specification
Device transform manager (DTM ) events
IMFDeviceTransform interface
KSCategory_Xxx Device Interface Classes
KSCATEGORY_SENSOR_CAMERA
KSCATEGORY_VIDEO_CAMERA
Windows kernel
Windows Kernel-Mode Process and Thread Manager - Starting in Windows 10 version 1703, the Windows
Subsystem for Linux (WSL ) enables a user to run native Linux ELF64 binaries on Windows, alongside other
Windows applications. For more information about WSL architecture and the user-mode and kernel-mode
components that are required to run the binaries, see the posts on the Windows Subsystem for Linux blog.
Mobile broadband
Updates to Mobile Broadband (MB ) include improved LTE attach features, support for Multi-SIM Operations,
support for provisioning contexts into the modem, support for the Specific Absorption Rate platform, and support
for network blacklisting.
Updates to Mobile Operator Scenarios (MOs) include a new database format called COSA FAQ, for MOs to
provision Windows Desktop MB devices. See these topics for more updates:
Planning your COSA/APN database submission
Submitting the COSA/APN database update
Testing your COSA/APN database submission
Networking
Updates to Networking driver development in Windows 10, version 1703 includes a new type of socket called
Stream Sockets, which support Linux networking applications on Windows. See Winsock Kernel for more info.
New functions and structures include WskConnectEx, WskListen, WSK_CLIENT_STREAM_DISPATCH, and
WSK_PROVIDER_STREAM_DISPATCH
POS
The following is a list of new topics for POS in Windows 10, version 1703:
Bluetooth barcode scanner UUIDs
BarcodeSymbologyDecodeLenthType enumeration
BarcodeSymbologyAttributesData structure
There is a new Gs1DWCode symbology to the BarcodeSymbology enumeration.
USB
Windows 10 version 1703 provides a new class extension (UcmTcpciCx.sys) that supports the Universal Serial Bus
Type-C Port Controller Interface Specification. A USB Type-C connector driver does not need to maintain any
internal PD/Type-C state. The complexity of managing the USB Type-C connector and USB Power Delivery (PD )
state machines is handled by the system. You only need to write a client driver that communicates hardware events
to the system through the class extension. For more information, see USB Type-C Controller Interface driver class
extensions reference.

Back to Top
This section describes new features and improvements for driver development in Windows 10, version 1607.
Audio
The following is a list of new topics for Audio driver development in Windows 10, version 1607.
Windows Audio Architecture
Structures and properties to better support the Cortana experience:
KSPROPERTY_AUDIO_MIC_SENSITIVITY
KSPROPERTY_AUDIO_MIC_SNR
KSAUDIO_PACKETSIZE_CONSTRAINTS2
PKEY_AudioEndpoint_Default_VolumeInDb – An INF key that provides the user a better experience when
appropriate gain or attenuation is applied to the audio signal.
Camera
Camera driver development in Windows 10, version 1607 includes new and updated topics to support Windows
Hello and face authentication:
Windows Hello camera driver bring up guide
Extended camera controls
KSPROPERTY_CAMERACONTROL_EXTENDED_FACEAUTH_MODE
Location
Location driver development in Windows 10, version 1607 includes the following new GNSS Breadcrumb DDIs:
GNSS_BREADCRUMB_LIST
GNSS_BREADCRUMB_V1
GNSS_BREADCRUMBING_ALERT_DATA
GNSS_BREADCRUMBING_PARAM
IOCTL_GNSS_LISTEN_BREADCRUMBING_ALERT
IOCTL_GNSS_POP_BREADCRUMBS
IOCTL_GNSS_START_BREADCRUMBING
IOCTL_GNSS_STOP_BREADCRUMBING
Print
Printer driver development in Windows 10, version 1607 includes JSConstraintsDebug, a command-line tool that
provides debugging support for JavaScript Constraints while developing a V4 printer driver.
WLAN
In Windows 10, version 1607, there are new and updated topics for WLAN Device Driver Interface (WDI) version
1.0.21. For details, see WDI doc change history.

Back to Top
This section describes new and updated features for driver development in Windows 10.
Bluetooth
In Windows 10, new Microsoft-defined Bluetooth HCI extensions have been added.
Buses and Ports
Driver programming interfaces and in-box drivers for Simple Peripheral Bus (SPB ) such as I2C and SPI, and GPIO
are part of OneCoreUAP -based editions of Windows. Those drivers will run on both Windows 10 for desktop
editions and Windows 10 Mobile, as well as other Windows 10 versions.
Camera
The camera driver DDIs have converged into a Universal Windows driver model, including new camera DDIs.
Additional features include:
Digital video stabilization
Variable frame rate
Face detection
Video high dynamic range (HDR )
Optical stabilization
Scene analysis: photo HDR, flash no flash, ultra low light
Capture stats: metadata framework/attributes, histograms
Smooth zoom
Hardware optimization hints
Camera profiles
Cellular
Cellular architecture and implementation for Windows 10 has been updated.
Display
The display driver model from Windows 8.1 and Windows Phone have converged into a unified model for
Windows 10.
A new memory model is implemented that gives each GPU a per-process virtual address space. Direct addressing
of video memory is still supported by WDDMv2 for graphics hardware that requires it, but that is considered a
legacy case. IHVs are expected to develop new hardware that supports virtual addressing. Significant changes have
been made to the DDI to enable this new memory model.
Human Interface Device (HID)
The new Virtual HID Framework (VHF ) eliminates the need for writing a kernel-mode transport minidriver. The
framework comprises a Microsoft-provided static library (Vhfkm.lib) that exposes programming elements used by
your driver. It also includes a Microsoft-provided in-box driver (Vhf.sys) that enumerates one or more child devices
and proceeds to build a virtual Human Interface Device (HID ) tree.
Write a HID source driver by using Virtual HID Framework (VHF )
Virtual HID Framework
Location
The Global Navigation Satellite System (GNSS ) driver DDIs have converged to a GNSS Universal Windows driver
model (UMDF 2.0).
Near Field Communication (NFC )
The NFC DDIs have a new converged driver model to support mobile and desktop solutions.
NFC Class Extension: A new NFC class extension driver is available. The NFC class extension driver implements all
of the Windows-defined DDIs to interact with the NFC controller, secure elements, and remote RF endpoints.
Networking
The new PacketDirect Provider Interface (PDPI) is available as an extension to the existing NDIS miniport driver
model. The PDPI provides an I/O model that allows applications to manage their own buffers, poll processors, and
directly manage sending and receiving packets over a miniport adapter. The combination of these capabilities allow
the application to completely control its own contexts leading to a much higher packet-per-second (pps) ratio.
Print
The print driver is updated with v4 Print driver improvements and changes to support wireless printing from
mobile devices, as well as the following:
V4 Driver Manifest – Provides information on changes to the v4 print driver manifest to support the PWG
Raster rendering filter, including updated DriverConfig and DriverRender directives, and an updated example
manifest.
WS -Discovery Mobile Printing Support – Describes the WS -Discovery requirements to enable mobile printing
from Windows 10 Mobile devices to Windows 10 Mobile compatible printers.
IXpsRasterizationFactory2 interface – Supports printer content conversion from XPS to PWG Raster using
the XPS Rasterization Service. PWG Raster supports non-square DPIs.
Print Pipeline Property Bag – New PrintDeviceCapabilities property to enable XPS rendering filters to
retrieve the new PrintDeviceCapabilities XML files from the Print filter pipeline property bag.
GetWithArgument Request and Response Schemas – Provides support for mobile printing with a formal
definition and example for the GetWithArgument request and response bidirectional communications schemas.
IBidiSpl::SendRecv method – Adds support for mobile printing with the GetWithArgument bidirectional
schema value.
Smart Card
In Windows 10, there is a new class extension module, Wudfsmcclassext.dll, which handles complex driver
operations. Smart card hardware-specific tasks are handled by your client driver. There are new programming
interfaces that your client driver can use to send information about the card to the class extension so that it can
process requests. Those driver programming interfaces are part of OneCoreUAP -based editions of Windows.
Smart card client driver event callback functions
Smart card client driver support methods
Storage
In Windows 10, new protocol-specific interfaces have been added to allow apps to talk with storage devices using
their native device protocol. These updates include:
Storage protocol pass through – The updated storage pass through IOCTL interface supports newer protocols
including non-volatile memory express (NVMe).
Expanded storage query interfaces – The expanded storage query interface allows applications to query
protocol-dependent information.
System-Supplied Driver Interfaces
The GUID_DEVICE_RESET_INTERFACE_STANDARD interface defines a standard way for function drivers to
attempt to reset and recover a malfunctioning device.
USB
Here are the new features for USB in Windows 10. For more information, see Windows 10: What's new for USB.
Native support for USB Type-C as defined in the USB 3.1 specification. If you are building a system with USB
Type-C connectors, you can use the in-box USB Type-C Connector System Software Interface (UCSI) driver or
write a USB Type-C connector driver..
The dual role feature allows a mobile device, such as a phone, a phablet or a tablet, to designate itself as being a
device or a host. See USB Dual Role Driver Stack Architecture for more information.
Support for writing a driver for USB emulated devices by using the Microsoft-provided USB device emulation
class extension (UdeCx).
Support for writing a driver for a host controller that is not xHCI specification-compliant or a virtual host
controller. To write such a driver, see Developing Windows drivers for USB host controllers.
Support writing function controller driver by using USB function class extension (UFX). See Developing
Windows drivers for USB function controllers.
WLAN
WDI (WLAN Device Driver Interface) is a new WLAN Universal Windows driver model that converges the WLAN
drivers on Windows 10 for desktop editions and Windows 10 Mobile.
Back to Top
Deprecated features
The following table describes Windows driver development features that have been removed in Windows 10.
DRIVER TECHNOLOGY FEATURE DEPRECATED IN
GNSS/Location Geolocation driver sample for Windows Windows 10, version 1709
8.1 and related documentation
Mobile Operator Scenarios AllowStandardUserPinUnlock Windows 10, version 1709

(Networking)
Scan/Image WSD (Web Services for Devices) Windows 10, version 1709
Challenger functionality and related
documentation
DRIVER TECHNOLOGY FEATURE DEPRECATED IN
Mobile Operators Mobile broadband app experience apps Windows 10, version 1803
with Sysdev metadata packages are
deprecated in favor of MO UWP APPS
and COSA.
Download the Windows Driver Kit (WDK)
The WDK is used to develop, test, and deploy Windows drivers. The latest public version of WDK is available
below.
Join the Windows Insider Program to get WDK Insider Preview builds. For installation instructions for the
Windows Insider Preview builds, see Installing preview versions of the Windows Driver Kit (WDK).
Learn what's new in driver development
Review known issues
WDK for Windows 10, version 1903
Step 1: Install Visual Studio 2019

The following editions of Visual Studio 2019 support driver development:
Download Visual Studio Community 2019
Download Visual Studio Professional 2019
Download Visual Studio Enterprise 2019
When you install Visual Studio 2019, select the Desktop development with C++ workload. The Windows 10
Software Development Kit (SDK) is automatically included, and is displayed in the right-hand Summary pane.
However, the version of the SDK that is compatible with the WDK for Windows 10, version 1903 is not currently
the default SDK. To select the correct SDK:
In Visual Studio Installer, on the Workloads tab, under Installation Details, expand Universal Windows
Platform development.
Under Optional, select Windows 10 Preview SDK (10.0.18362.0).
Continue with the install.
If you already have Visual Studio 2019 installed, you can install the Windows 10 Preview SDK (10.0.18362.0) by
using the Modify button in Visual Studio install.
For ARM/ARM64 driver development, choose Individual components and under Compilers, build tools, and
runtimes select Visual C++ compilers and libraries for ARM/ARM64.
For each architecture you intend to build drivers for, install the Spectre mitigated libraries thru Individual
Components -> Compilers, build tools, and runtimes -> MSVC v142 - VS 2019 C+ x64/x86 Spectre-mitigated libs
(v14.21).
Step 2: Install WDK for Windows 10, version 1903

Download WDK for Windows 10, version 1903
New as of 1709 release: The WDK installation will by default install the WDK Visual Studio extension. This must be
done in order for WDK VS integration to work.
Enterprise WDK for Windows 10, version 1903 (EWDK)
The EWDK is a standalone self-contained command-line environment for building drivers. It includes the Visual
Studio Build Tools, the SDK, and the WDK. The latest public version of the EWDK contains Visual Studio 2019
Build Tools 16.0.0. To get started, mount the ISO and run LaunchBuildEnv.
EWDK with Visual Studio Build Tools

Download EWDK for Windows 10, version 1903
Additional information
Release notes and run-time requirements
WDK requires Visual Studio, for more information more info on system requirements for Visual Studio please
review Visual Studio 2019 System Requirements.
EWDK will additionally need .NET 4.7.2, for more information on what .NET runs on please review .NET
Framework system requirements.
You can use the WDK to develop drivers for these operating systems:
CLIENT OS SERVER OS
Windows 10 Windows Server 2019, Windows Server 2016
Windows 8.1 Windows Server 2012 R2
Windows 8 Windows Server 2012
Windows 7 Windows Server 2008 R2 SP1
Universal Windows driver samples

To get universal Windows driver samples, do one of the following:
Go to the driver samples page on GitHub and click Clone or download > Download ZIP on the right side of
the page.
Download the GitHub Extension for Visual Studio to connect to the GitHub repositories.
Browse the driver samples on the Microsoft Samples portal.
Related downloads
Download the WDK Insider Preview
Download previous versions of the WDK
Download the Windows Assessment and Deployment Kit (Windows ADK)
Download the Windows HLK, HCK, or Logo Kit
Download the debugging Tools for Windows (WinDbg)
Download Windows Symbol Packages
Installing preview versions of the Windows Driver Kit
(WDK)
This page contains installation instructions for Insider Preview (pre-release) versions of the Windows Driver Kit
(WDK). The download links for the latest pre-release version of the WDK and the EWDK are on
https://www.microsoft.com/software-download/windowsinsiderpreviewWDK.
For info about the latest released versions of the WDK, see Download the Windows Driver Kit (WDK). For
downloads of earlier versions of the WDK, see Other WDK downloads.
Install Windows Driver Kit (WDK) Insider Preview

1. Install Visual Studio
The WDK now supports Visual Studio 2019. All editions are supported. The WDK no longer supports Visual
Studio 2017.
Download from https://visualstudio.microsoft.com/vs/preview/.
Select workload: Development with C++.
ARM: To build ARM drivers you must additionally install the component: Individual components -> Compilers,
build tools, and runtimes -> Visual C++ compilers and libraries for ARM.
ARM64: Currently not supported.
2. Disable strong name validation
The WDK Visual Studio Extensions are currently not strong name signed. Run the following commands from an
elevated command prompt to disable strong name validation:
reg add HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\StrongName\Verification\*,31bf3856ad364e35 /v TestPublicKey /t

REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7ac83af7401b14c1bd103973b26dfafb2b7
7eda478a2539b979b56ce47f36336741b4ec52bbc51fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89
f21cd028377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f19a52b8a29dc31b0 /f
reg add HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\StrongName\Verification\*,31bf3856ad364e35 /v

TestPublicKey /t REG_SZ /d
00240000048000009400000006020000002400005253413100040000010001003f8c902c8fe7ac83af7401b14c1bd103973b26dfafb2b7
7eda478a2539b979b56ce47f36336741b4ec52bbc51fecd51ba23810cec47070f3e29a2261a2d1d08e4b2b4b457beaa91460055f78cc89
f21cd028377af0cc5e6c04699b6856a1e49d5fad3ef16d3c3d6010f40df0a7d6cc2ee11744b5cfb42e0f19a52b8a29dc31b0 /f
3. Install SDK Insider Preview

Get SDK Insider Preview
4. Install WDK Insider Preview
Get WDK Insider Preview
NOTE
During installation you will see the Visual Studio installer install the WDK Visual Studio Extensions.
Install Enterprise WDK (EWDK) Insider Preview

The EWDK is a standalone self-contained command-line environment for building drivers. It includes Build Tools
for Visual Studio 2019, the SDK, the WDK and support for ARM64 driver development. See more at Installing the
Enterprise WDK.
Get the Enterprise Windows Driver Kit (EWDK) Insider Preview
To get started mount the ISO and click LaunchBuildEnv.
Run-time requirements for the WDK and the EWDK

The WDK requires Visual Studio. For more info about system requirements for Visual Studio, see Visual Studio
2019 System Requirements.
In addition, the EWDK requires .NET 4.7.2. For more info about what .NET runs on, see .NET Framework system
requirements.
You can use the WDK Insider Preview and the EWDK Insider Preview to develop drivers for these operating
systems:
CLIENT OS SERVER OS
Windows 8.1 Windows Server 2012 R2
Windows 7 Windows Server 2008 R2 SP1

Other WDK downloads
This topic contains information about earlier versions of the Windows Driver Kit (WDK), Enterprise WDK (EWDK),
and additional downloads for support purposes. To develop drivers, use the latest public versions of the Windows
Driver Kit (WDK) and tools, available for download on Download the Windows Driver Kit (WDK).
The Windows Driver Kit (WDK) is used to develop, test, and deploy Windows drivers. To develop drivers, use the
latest public versions of the Windows Driver Kit (WDK) and tools, available for download on Download the
Windows Driver Kit (WDK).
This topic contains information about earlier versions of the WDK, the Enterprise WDK (EWDK), and additional
downloads for support purposes. To use these earlier versions, you must first install the version of Visual Studio
that is appropriate for your targeted platform.
Step 1: Install Visual Studio

Development of drivers is supported for specific versions of Visual Studio. To develop a driver for a specific
version of Windows, you must use one of the versions of Visual Studio that are identified (and linked for
download) in the following table.
TARGETED VERSIONS OF WINDOWS EDITION(S) OF VISUAL STUDIO
Windows 10, version 1809 Visual Studio Community 2017

Windows 10, version 1803 Visual Studio Professional 2017
Windows 10, version 1709 Visual Studio Enterprise 2017
Windows 10, version 1703 Visual Studio Express 2015 for Desktop
Windows 10, version 1607 Visual Studio Community 2015
Visual Studio Professional 2015
Visual Studio Enterprise 2015
Windows 8.1 Update Visual Studio 2013

Windows 8.1
Windows 8 Visual Studio Professional 2012

Visual Studio Ultimate 2012
Configure Visual Studio for Windows 10, versions 1709, 1803, and 1809
When you install Visual Studio, select the Desktop development with C++ workload. The Windows 10
Software Development Kit (SDK) is automatically included and is displayed in the right-hand Summary pane.
To develop drivers for ARM/ARM64, choose Individual components and under Compilers, build tools, and
runtimes select Visual C++ compilers and libraries for ARM/ARM64.
Install the Windows SDK to target Windows 10, versions 1607 and 1703
If your development targets systems that run Windows 10, version 1607 or Windows 10, version 1703, you
should install Visual Studio 2015, and then also download and install the version of the Windows SDK for the
targeted version of Windows 10, as identified in the following table.
TARGETED VERSIONS OF WINDOWS VERSION OF WINDOWS SDK
Windows 10, version 1703 Windows SDK for Windows 10.0.15063.468
Windows 10, version 1607 Windows SDK for Windows 10.0.14393.795
Windows 8.1 Windows SDK for Windows 8.1
Windows 8 Windows SDK for Windows 8
The Windows SDK was not included in Visual Studio 2015, so you must install the SDK separately. Later versions
of Visual Studio include the Windows SDK.
Step 2: Install the WDK

The WDK is integrated with Visual Studio and Debugging Tools for Windows (WinDbg). This integrated
environment gives you the tools you need to develop, build, package, deploy, test, and debug drivers.
NOTE
Starting with Windows 10, version 1709, installing the WDK will by default install the WDK extensions for Visual Studio.
These extensions are required for integration of the WDK with Visual Studio.
VERSIONS OF WINDOWS WDK AND RELATED DOWNLOADS
Windows 10, version 1809 WDK for Windows 10, version 1809
Windows 8.1 Update WDK 8.1 Update (English only)

WDK 8.1 Update Test Pack (English only)
WDK 8.1 Samples
Windows 8 WDK 8 (English only)

WDK 8 redistributable components (English only)
WDK 8 Samples
Windows XP WDK 7.1.0

Windows Server 2003
IMPORTANT
If you have installed the WDK for Windows 10, version 1703 on a system that had the WDK for Windows 10, version 1607
installed, some files from the earlier version of the WDK might have been removed. To restore these files:
1. On the Start menu, enter Apps & features in the search box, and select Apps & features from the results.
2. Find Windows Driver Kit - Windows 10.0.15063.0 in the list of Apps & Features, and then select the program.
3. Select Modify, select Repair, and then follow the directions on the screen.
4. The files will be restored.
Optional: Install the EWDK

The Enterprise WDK (EWDK) is a standalone, self-contained, command-line environment for building drivers and
basic Win32 test applications. It includes the Visual Studio Build Tools, the SDK, and the WDK. This environment
doesn't include all the features available in Visual Studio, such as the integrated development environment (IDE ).
Using the EWDK requires .NET Framework 4.6.1. For more information about which systems run this version of
the framework, see .NET Framework system requirements. For links to download the .NET Framework, see Install
the .NET Framework for developers.
For more information about the EWDK, see Using the Enterprise WDK 10.
VERSIONS OF WINDOWS EWDK
Windows 10, version 1809 EWDK for Windows 10, version 1809
Windows 10, version 1709 EWDK for Visual Studio with Build Tools 15.6 (Recommended)
EWDK for Visual Studio with Build Tools 15.4
EWDK for Visual Studio with Build Tools 15.2
NOTE
Starting in Windows 10 version 1709, the EWDK is ISO-based. To get started, download and mount the ISO, and then run
LaunchBuildEnv.
Optional: Install updated test certificates for HAL extensions

To work with HAL Extensions, prepare your development system, running Windows 10, version 1709 or a later
version of Windows 10. Also install the WDK or the EWDK, and then install the updated version of the Windows
OEM HAL Extension Test Cert 2017 (TEST ONLY ), available for download as a ZIP file:
HAL_Extension_Test_Cert_2017.zip.
For more information about using this updated certificate, see Update for "Windows OEM HAL Extension Test
Cert 2017 (TEST ONLY )" test certificate on Windows Support.
Optional: Install WinDbg Preview

WinDbg Preview is a new version of WinDbg with more modern visuals, faster windows, a full-fledged scripting
experience, built with the extensible debugger data model front and center. WinDbg Preview supports debugging
every version of Windows 10.
For download links and more information about WinDbg Preview, see Download WinDbg Preview.
Standalone tools for debugging Windows XP and Windows Vista

If you're debugging Windows XP, Windows Server 2003, Windows Vista, or Windows Server 2008 (or using one
of these operating systems to run Debugging Tools for Windows), you need to use the Windows 7 release of the
debugging tools. It's included in the SDK for Windows 7 and .NET Framework 4.0.
IMPORTANT
Newer versions of the Visual C++ 2010 Redistributable can cause issues when you install the SDK for Windows 7. For more
information, see Windows SDK Fails to Install with Return Code 5100 on Microsoft Support.
Get the standalone debugging tools for Windows XP by first downloading the Windows 7 SDK: Microsoft
Windows SDK for Windows 7 and .NET Framework 4.
To install the Debugging Tools for Windows as a standalone component, start the SDK installer, and in the
installation wizard, select Debugging Tools for Windows, and clear all other components.
Related downloads
Download the Windows Assessment and Deployment Kit (Windows ADK)
Download the Windows HLK, HCK, or Logo Kit
Download the debugging Tools for Windows (WinDbg)
Download Windows Symbol Packages
Download the WDK Insider Preview
Bring up guide
NOTE
Some topics in this section may apply only to Windows 10 Mobile and certain processor architectures.
This section of the partner documentation is designed for hardware engineers and developers who need to
understand how to get started with bringing up hardware on Windows 10 and Windows Server 2016.
In this section
TOPIC DESCRIPTION
Firmware Windows Engineering Guide (WEG) The Firmware Windows Engineering Guide (WEG) provides
a roadmap to follow through in implementing system
firmware-related best practices.
Boot and UEFI Provides guidance about the boot process and UEFI
implementation requirements for devices that run
Windows 10 and Windows Server 2016.
Windows ACPI design guide for SoC platforms The Advanced Configuration and Power Interface
Specification, Revision 5.0 (ACPI 5.0 specification), defines
a new set of features to support low-power, mobile
devices that are based on System on a Chip (SoC)
integrated circuits and that implement the connected
standby power model. Starting with Windows 8 and
Windows 8.1, and Windows Server 2012 and 2012 R2,
Windows supports the new ACPI 5.0 features for SoC-
based platforms.
Security Use the topics in this section to learn more about security
in Windows 10 Mobile and Windows Server 2016.
Windows 10 Mobile partition layout Learn how to configure storage partitions and partitions
sizes on Windows 10 Mobile devices.
Developing, Testing, and Deploying Drivers
The Windows driver development environment and the Windows debuggers are integrated into Microsoft Visual
Studio. In this integrated driver development environment, most of the tools you need for coding, building,
packaging, deploying, and testing a driver are available in the Visual Studio user interface.
To set up the integrated development environment, first install Visual Studio and then install the WDK. You can find
information about how to get Visual Studio and the WDK here. Debugging Tools for Windows is included when
you install the WDK.
The WDK uses MSBuild.exe, which is available both in the Visual Studio user interface and as a command-line tool.
Drivers created in the Visual Studio environment use Project and Solution files to describe a project or group of
projects. The Visual Studio environment provides a tool for converting legacy Sources and Dirs files to Project and
Solution files.
The Visual Studio environment provides templates for:
New drivers
Driver packages
New tests
Enhancement of existing tests
Custom driver deployment scripts
In the Visual Studio environment, you can configure the build process so that it automatically creates and signs a
driver package. Static and run-time analysis tools are available in Visual Studio. You can configure a target
computer for testing your driver and automatically deploy your driver to the target computer each time you
rebuild. You can choose from an extensive set of run-time tests, and you can write your own tests.
The topics in this section show you how to use Visual Studio to perform several of the tasks involved in driver
development, deployment, and testing.
Additional Videos
You'll find videos on the following pages in the Windows driver docs:
What's New in HID
Capture and view USB traces with Microsoft Message Analyzer
Using the Windows Performance Toolkit (WPT) with WDF
Video: Accessing driver IFR logs without a debugger
Video: Debugging your driver with WDF source code
Videos: Debugging UMDF Drivers
The Partner Center for Windows Hardware enables you to create and manage your system and driver submissions quickly and
easily. It replaces the legacy (Sysdev) dashboard for hardware tasks including: hardware certification, collaborative driver
development, and driver distribution through Windows Update. To get started, watch our introductory video series, and see Get
started with the hardware program for registration details.
NOTE
The legacy (Sysdev) dashboard has been retired. Use the Partner Center Hardware dashboard for your hardware tasks.
Hardware Submissions
Create a new driver submission
Manage your hardware submissions
Driver flighting
Device metadata
Driver distribution
Publish a driver to windows update
Share a driver with a partner
Working with extension INF files
Hardware dashboard API

Manage hardware submissions using APIs
Get product data
Manage product submissions
Dashboard administration
Register for the hardware program
Add or remove users
Add a code signing certificate
Dashboard information
Getting started with the hardware dashboard
Hardware dashboard FAQ
LSA and UEFI file signing
This section explains how devices and drivers are installed in Windows.
If you are unfamiliar with the device and driver installation process, we recommend that you start by reviewing
Roadmap for Device and Driver Installation. You may also want to read Overview of Device and Driver Installation
for a high-level overview of this process and its components.
This section includes general concepts to help you understand kernel-mode programming and describes specific
techniques of kernel programming. This section is divided into four parts:
Introduction to Windows Drivers provides a general overview of Windows components, lists the types of
device drivers used in Windows, discusses the goals of Windows device drivers, and discusses generic
sample device drivers included in the kit.
Kernel-Mode Managers and Libraries lists the primary kernel-mode components of the Windows operating
system.
Writing WDM Drivers provides information needed to write drivers using the Windows Driver Model
(WDM ).
Driver Programming Techniques describes techniques that you can use to program Windows kernel-mode
device drivers.
Note For information about programming interfaces that your driver can implement or call, see Kernel-
Mode Driver Reference.
What's New for WDF Drivers in Windows 10
This topic summarizes the new features and improvements for Windows Driver Frameworks (WDF ) drivers in
Windows 10.
Windows 10, version 1903 (March 2019 Update, 19H1) includes Kernel-Mode Driver Framework (KMDF ) version
1.29 and User-Mode Driver Framework (UMDF ) version 2.29.
You can use these framework versions to build drivers for:
Windows 10 (all SKUs)
Windows Server, version 1809
For version history, see KMDF Version History and UMDF Version History. Except where noted, UMDF references
on this page describe version 2 functionality that is not available in UMDF version 1.
New in WDF for Windows 10, version 1903

No functionality added or changed.

Added new API WdfDriverRetrieveDriverDataDirectoryString

Building a WDF driver for multiple versions of Windows.
WdfDeviceRetrieveDeviceDirectoryString

See KMDF Version History and UMDF Version History.

In Windows 10, version 1703, WDF includes the following enhancements:
New WDF Verifier settings to detect excessive object creation
In some cases, framework objects are incorrectly parented and not deleted after use. With this feature, you
can specify a maximum number of objects and what should happen when this threshold is exceeded.
To start monitoring, add the following registry values under:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\<driver service>\Parameters\wdf
1. Add a DWORD value named ObjectLeakDetectionLimit with the threshold value. This is the
maximum number of objects of the types described in the ObjectsForLeakDetection key.
2. Add a new REG_MULTI_SZ value named ObjectsForLeakDetection that lists each type name to
verify. For example, you could specify WDFDMATRANSACTION WDFDEVICE . To specify all handle types, use
* as the string.
3. To control whether exceeding this threshold should cause a debug break or a bugcheck, set the
DbgBreakOnError key.
By default, if the ObjectsForLeakDetection key is not specified, the framework monitors
WDFREQUEST, WDFWORKITEM, WDFKEY, WDFSTRING, WDFOBJECT, and WDFDEVICE.
The limit scales with the number of devices installed, so if the driver creates three WDFDEVICE
objects, the WDF Verifier limit is three times the value specified in ObjectLeakDetectionLimit.
If you specify WDFREQUEST, the verifier only counts WDFREQUEST objects that the driver creates.
This feature does not currently support tracking the WDFMEMORY object type.
SleepStudy tool provides info on KMDF drivers
The SleepStudy software tool reports the number of power references that a KMDF driver has that are
preventing the system from going to sleep. For more info, see Modern standby SleepStudy.
The rest of this page describes functionality that was added in Windows 10, version 1507.
WDF source code is publicly available

The WDF source code is now available as open source on GitHub. This is the same source code from which
the WDF runtime library that ships in Windows 10 is built. You can debug your driver more effectively when
you can follow the interactions between the driver and WDF. Download it from
https://github.com/Microsoft/Windows-Driver-Frameworks.
The private symbol files for WDF on Windows 10 are now available through the Microsoft Symbol Server.
The Windows Driver Kit (WDK) 10 samples are also now published to GitHub. Download them from
https://github.com/Microsoft/Windows-Driver-Samples.
Automatic Source Level Debugging of Framework Code

When you use WinDbg to debug a WDF driver on Windows 10, WinDbg automatically retrieves the framework
source code from Microsoft's public GitHub repository. You can use this feature to step through the WDF source
code while debugging, and to learn about framework internals without downloading the source code to a local
machine. For more information, see New support for source-level debugging of WDF code in Windows 10,
Debugging with WDF Source, and Video: Debugging your driver with WDF source code.
Universal Driver Compliance

All WDF driver samples and Visual Studio driver templates are Universal Windows driver compliant.
All KMDF and UMDF 2 functionality is Universal Windows driver compliant.
Note that UMDF 1 drivers run only on Windows 10 for desktop editions and earlier versions of desktop Windows.
Want to benefit from the universal capabilities of UMDF 2? To learn how to port your old UMDF 1 driver, see
Porting a Driver from UMDF 1 to UMDF 2.
Debugging and Diagnosability

All KMDF and UMDF 2 drivers can use an always on, always available Inflight Trace Recorder (IFR ). When a
driver provides a custom trace, the driver IFR log contains the trace messages. Note that the new driver IFR
log is separate from the framework IFR log that WDF creates for each driver.
It's easy to turn on the IFR. See Inflight Trace Recorder (IFR ) for logging traces and Using Inflight Trace
Recorder in KMDF and UMDF Drivers.
The IFR maintains a circular buffer of WPP traces in non-pageable memory. If a driver crashes, the logs are
frequently included in the crash dump file.
If you turn on the IFR in your driver binary, the IFR is present and running during the lifetime of your driver.
You don't need to start an explicit trace collection session.
IFR logs are included in minidump files except when the responsible driver is undetermined or if the
crash was a host timeout.
If you have a debugger connected, you can access both the driver and framework IFR logs by issuing
!wdfkd.wdflogdump.
If you do not have a debugger connected, you can still access both logs. To learn how, see Video:
Accessing driver IFR logs without a debugger.
When debugging a UMDF driver, you can merge framework logs with driver logs by issuing:
!wdfkd.wdflogdump <drivername.dll> -m
UMDF logs (WudfTrace.etl) and dumps are now located in %ProgramData%\Microsoft\WDF instead of
%systemDrive%\LogFiles\Wudf.
New debugger command: !wdfkd.wdfumtriage provides a kernel-centric view of all UMDF devices on the
system.
You can run !analyze to investigate UMDF verifier failures or UMDF unhandled exceptions. This works for
live kernel debugging as well as debugging user crash dump files from %ProgramData%\Microsoft\WDF.
In KMDF and UMDF 2, you can monitor power reference usage in the debugger. For info, see Debugging
Power Reference Leaks in WDF.
You can use !wdfkd.wdfcrashdump to display error information about UMDF 2 drivers. For more
information, see !wdfkd.wdfcrashdump.
Performance Tracing tool for WDF drivers

You can use the Windows Performance Toolkit (WPT) to view performance data for a given KMDF or UMDF 2
driver. When tracing is enabled, the framework generates ETW events for I/O, PnP, and Power callback paths. You
can then view graphs in the Windows Performance Analyzer (WPA) that show I/O throughput rates, CPU
utilization, and callback performance. The WPT is included in the Windows Assessment and Deployment Kit (ADK).
For more information, see New Performance Tools for WDF Drivers in Windows 10 and Using the Windows
Performance Toolkit (WPT) with WDF.
Additional support for HID drivers in UMDF

UMDF now fully supports HID filters (enumerated by HIDClass) and minidrivers. Simply port your existing
KMDF driver or write a new UMDF 2 filter; the functionality is automatically enabled.
UMDF HID minidrivers that are enumerated by ACPI can perform selective suspend. For more information,
see Creating WDF HID Minidrivers.
UMDF drivers can now be installed in the HID stack for low latency input devices such as touch and mouse.
A driver for an input device should specify the UmdfHostPriority INF directive. For information, see
Specifying WDF Directives in INF Files.
Support for interrupts for GPIO-backed devices

UMDF 2 supports interrupts for GPIO -backed devices like hardware push-buttons. KMDF supports these
devices natively, without the workaround described in Handling Active-Both Interrupts. For more information,
see Creating an Interrupt Object.
UMDF no longer requires WinUSB

New support has been added for USB drivers in UMDF. A UMDF 2 USB driver no longer uses WinUSB. To use
the new functionality, the driver sets the UmdfDispatcher directive to NativeUSB, instead of WinUSB. See
Specifying WDF Directives in INF Files.
Improved Performance
UMDF system components consume less disk space.
KMDF and UMDF drivers use less non-paged memory.
Improved framework version checking reduces header/library mismatches.
UMDF provides improved buffer mapping for HID transfers.
Driver Security Guidance
This section contains information on enhancing driver security.
In this section
TOPIC DESCRIPTION
Driver security checklist This topic provides a driver security checklist for driver
developers.
Threat modeling for drivers Driver writers and architects should make threat modeling
an integral part of the design process for any driver. This
topic provides guidelines for creating threat models for
drivers.
Windows security model for driver developers This topic describes how the Windows security model
applies to drivers and explains what driver writers must do
to improve the security of their devices.
Use the Device Guard Readiness Tool to evaluate HVCI This topic describes how to use the tool to evaluate the
driver compatibility ability of a driver to run in a Hypervisor-protected Code
Integrity (HVCI) environment.
Debugging Tools for Windows (WinDbg, KD, CDB,
NTSD)
Start here for an overview of Debugging Tools for Windows. This tool set includes WinDbg and other debuggers.
Install Debugging Tools for Windows

You can get Debugging Tools for Windows as part of a development kit or as a standalone tool set:
As part of the WDK
Debugging Tools for Windows is included in the Windows Driver Kit (WDK). To get the WDK, see Download
the Windows Driver Kit (WDK).
As part of the Windows SDK
Debugging Tools for Windows is included in the Windows Software Development Kit (SDK). To download
the installer or an ISO image, see Windows 10 SDK on Windows Dev Center.
As a standalone tool set
You can install the Debugging Tools for Windows alone, without the Windows SDK or WDK, by starting
installation of the Windows SDK and then selecting only Debugging Tools for Windows in the list of
features to install (and clearing the selection of all other features). To download the installer or an ISO
image, see Windows 10 SDK on Windows Dev Center.
Get started with Windows Debugging

To get started with Windows debugging, see Getting Started with Windows Debugging.
To get started with debugging kernel-mode drivers, see Debug Universal Drivers - Step by Step Lab (Echo Kernel-
Mode). This is a step-by-step lab that shows how to use WinDbg to debug Echo, a sample driver that uses the
Kernel-Mode Driver Framework (KMDF ).
Debugging environments
If your computer has Visual Studio and the WDK installed, then you have six available debugging environments.
For descriptions of these environments, see Debugging Environments.
All of these debugging environments provide user interfaces for the same underlying debugging engine, which is
implemented in the Windows Symbolic Debugger Engine (Dbgeng.dll). This debugging engine is also called the
Windows debugger, and the six debugging environments are collectively called the Windows debuggers.
NOTE
Visual Studio includes its own debugging environment and debugging engine, which together are called the Visual Studio
debugger. For information on debugging in Visual Studio, see Debugging in Visual Studio. For debugging managed code,
such as C#, using the Visual Studio debugger is often the easiest way to get started.
Windows debuggers
The Windows debuggers can run on x86-based, x64-based, or ARM -based processors, and they can debug code
that is running on those same architectures. Sometimes the debugger and the code being debugged run on the
same computer, but other times the debugger and the code being debugged run on separate computers. In either
case, the computer that is running the debugger is called the host computer, and the computer that is being
debugged is called the target computer. The Windows debuggers support the following versions of Windows for
both the host and target computers.
Windows 10 and Windows Server 2016
Windows 8.1 and Windows Server 2012 R2
Windows 8 and Windows Server 2012
Windows 7 and Windows Server 2008 R2
Symbols and symbol files

Symbol files store a variety of data that are not required when running the executable binaries, but symbol files are
very useful when debugging code. For more information about creating and using symbol files, see Symbols for
Windows debugging (WinDbg, KD, CDB, NTSD ).
Blue screens and crash dump files

If Windows stops working and displays a blue screen, the computer has shut down abruptly to protect itself from
data loss and displays a bug check code. For more information, see Bug Checks (Blue Screens). You analyze crash
dump files that are created when Windows shuts down by using WinDbg and other Windows debuggers. For
more information, see Crash dump analysis using the Windows debuggers (WinDbg).
Tools and utilities

In addition to the debuggers, Debugging Tools for Windows includes a set of tools that are useful for debugging.
For a full list of the tools, see Tools Included in Debugging Tools for Windows.
Additional documentation
For additional information related to Debugging Tools for Windows, see Debugging Resources. For information on
what's new in Windows 10, see Debugging Tools for Windows: New for Windows 10.
UWP device apps
Purpose
Device manufacturers can create a UWP device app that serves as a companion to their device. UWP device apps
have more capabilities than regular UWP apps and can perform privileged operations, such as firmware updates.
Also, UWP device apps can start from AutoPlay (on more devices than other apps can), automatically install the
first time a device is connected, and extend the printer and camera experiences built into Windows 8.1 and
Windows 10.
This section describes what UWP device apps are and how device manufacturers can create them. If you're new to
UWP device apps, take a look at Getting started.
If you're looking for info about UWP mobile broadband apps, see Mobile Broadband.
In this section
TOPIC DESCRIPTION
What's new This section provides a glimpse of what's new for UWP
device apps.
Getting started Start here to begin building UWP device apps.
Build a UWP device app step-by-step This step-by-step guide describes in detail how to build a
UWP device app with Microsoft Visual Studio and the
Device Metadata Authoring Wizard.
AutoPlay for UWP device apps This topic describes how to use the Device Metadata
Authoring Wizard to enable AutoPlay. It also describes
how to handle AutoPlay activations in your app.
Device sync and update for UWP device apps In Windows 8.1, your UWP app can use a device
background task to synchronize data on your peripheral
device. If your app is associated with device metadata, that
UWP device app can also use a device background agent
to perform device updates, such as firmware updates.
UWP device apps for printers This section introduces UWP device apps for printers.
UWP device apps for cameras This section introduces UWP device apps for cameras.
UWP device apps for internal devices This topic introduces the ways that UWP device apps can
access internal devices.
TOPIC DESCRIPTION
Automatic installation for UWP device apps This topic describes how automatic installation works and
how the app, metadata, and drivers can be updated and
uninstalled.
Hardware Support App (HSA): Steps for Driver Developers This topic provides steps for a driver developer to
associate a driver with a Universal Windows Platform
(UWP) app.
Hardware Support App (HSA): Steps for App Developers This topic provides steps for an app developer to associate
a Universal Windows Platform (UWP) app with a Universal
Windows driver.
Overview of Driver Technologies
For general information about developing drivers see Getting started with Windows drivers and Write your first
driver.
The majority of the driver technology information is the same for all editions of Windows 10. When you must
make special considerations for a particular edition of Windows, such as for Windows 10 Mobile, we explicitly
called these out in each technology area.

You can create a Universal Windows driver—a driver that uses a subset of the interfaces that are available to a
Windows driver—to run on all editions of Windows 10. Where possible, use a Universal Windows driver to enable
deployment of your drivers on multiple devices. For more information about how to build, install, deploy, and
debug a Universal Windows driver for Windows 10, see Getting Started with Universal Windows drivers and
Deploying a Driver to a Test Computer.
Device drivers and Windows 10 for desktop computers

For information about the tools used to develop desktop drivers, see Driver Development Tools and Tools for
Verifying Drivers. For information about deploying drivers to Windows 10 on a desktop, see Device and Driver
Installation. For information about troubleshooting driver installation, see Troubleshooting Configuration of Driver
Deployment, Testing and Debugging.
Driver technologies
3D print devices
ACPI
Audio
Battery Drivers
Biometric Drivers
Bluetooth Drivers
Display drivers
File system drivers
GNSS drivers
GPIO drivers
HID Drivers
IEEE Drivers
Imaging device drivers
Kernel-mode driver technology
Mobile broadband
Multifunction device drivers
NetAdapterCx
Network drivers
NFC device drivers
Parallel port drivers
Partner application development
PCI drivers
PCMCIA drivers
Point of Service device drivers
Power management technologies
Print device drivers
SD card bus drivers
Sensor drivers
Serial port drivers
Smartcard device drivers
Simple Peripheral Bus (SPB ) drivers
Storage device drivers
Streaming media device drivers
Test Authoring and Execution Framework (TAEF )
Universal Serial Bus (USB )
Windows Device Testing Framework (WDTF )
Windows portable device drivers
Related sections
Partner Center for Windows Hardware
3D printer driver design guide
This section provides information about 3D printer drivers in Windows 10.

3D printing in Windows 10 provides the following features:
Driver model for 3D manufacturing devices
Support for UWP apps and extensions for 3D devices
Job spooling and queuing support
Keywords for modeling device capabilities
API for apps to submit 3D manufacturing jobs to your 3D printer
For the latest information about 3D printing in Windows 10, see the following resources:
3D printing on Windows
3D hardware partners
3D Builder resources
3D Builder user's guide
Channel 9 3D printing blog
Download the Windows 3D Printing SDK to start developing drivers for printing to a 3D printer.
In this section
3D print partner onboarding guide
Microsoft Standard Driver for 3D Printers
MS3DPrint Standard G -Code driver
3D printer custom USB interface support
3D printing sample WSD app
Enable WSPrint 2.0 on a device
Print schema keywords for 3D manufacturing
3D hardware partners
Related sections
Print DDI reference
ACPI design guide
This section describes how device drivers can interface with an Advanced Configuration and Power Interface
(ACPI) device. ACPI devices are defined by the Advanced Configuration and Power Interface (ACPI) Specification.
In this section
SECTION DESCRIPTION
Supporting ACPI Devices Provides information about how to use a Windows Driver
Model (WDM) function driver to enhance the functionality of
an ACPI device.
Evaluating ACPI Control Methods Provides information about how device drivers that comply
with the requirements of Kernel-Mode Driver Framework
(KMDF), User-Mode Driver Framework (UMDF), or Windows
Driver Model (WDM) can evaluate ACPI control methods.
How to Identify the Windows Version in ACPI by Using _OSI Provides information about the ACPI Source Language (ASL)
Operating System Interface Level (_OSI) method used to
identify the host operating system.
Related sections
ACPI DDI reference
Audio Devices Design Guide
This section describes how to design Microsoft Windows Driver Model (WDM ) audio drivers. These drivers
control audio adapters that render and capture streams containing audio data in wave and MIDI formats.
The following topics are discussed:
Windows 10: What's New for Audio Drivers
Windows Audio Architecture
Roadmap for Developing WDM Audio Drivers
WDM Audio Drivers Overview
WDM Audio Architecture: Basic Concepts
WDM Audio Architecture: Advanced Topics
WDM Audio Support in Different Versions of Windows
Windows Audio Processing Objects
Audio Miniport Drivers
Legacy Audio Interfaces
Battery Devices Design Guide
A battery typically has a pair of drivers: the generic battery class driver that Microsoft provides, and a miniclass
driver written specifically for that individual type of battery.
The class driver defines the overall functionality of the batteries in the system and interacts with the power
manager.
This design guide focuses on Writing Battery Miniclass Drivers.
In addition this section includes information on Writing UPS Minidrivers that were used with older versions of
Windows.
Biometric Devices Design Guide
This section describes how to write user-mode drivers that work with the Windows Biometric Driver Interface
(WBDI). WBDI is the driver interface of the Windows Biometric Framework (WBF ). WBF ships with Windows 7
and later versions of the Windows operating system.
In this section
Getting Started with Biometric Drivers
Roadmap for Developing Biometric Drivers
Sample Biometric Driver
Supporting Biometric IOCTL Calling Sequence
Using WinUSB in a WBDI Driver
Installing a Biometric Driver
Managing Queues in a WBDI Driver
Creating a Device Interface for a WBDI Driver
Supporting Secure Channels in WBDI Drivers
Using WBDI with Non-PnP Devices or Proprietary Stacks
Hardware Considerations for Biometric Drivers
Ranking a Biometric Driver on Windows Update
Testing Biometric Drivers
Signing WBDI Drivers
Windows Hello: Steps to Submit a Fingerprint Driver
Custom Control Codes
Bluetooth Profile Drivers
This section describes Bluetooth profile drivers. The information in this section is divided into the following topics:
Bluetooth Profile Drivers Overview
Bluetooth Low Energy Overview
Using the Bluetooth Driver Stack
Debugging Bluetooth Profile Drivers
Bluetooth FAQ
Transport Bus Driver for Bluetooth Power Control Handling Guidelines
Bluetooth LE Proximity Profile Devices and Apps
Display Devices Design Guide
Welcome to the Windows Display Driver Design Guide. This section includes:
Windows Display Driver Model (WDDM ) Design Guide
WDDM is the display/graphics driver architecture available starting with Windows Vista. Drivers that
adhere to WDDM run only on Windows Vista and later.
Windows 2000 Display Driver Model (XDDM ) Design Guide
XDDM is the display/graphics driver architecture available for Windows 2000 through Windows Vista and
Windows 7. XDDM and VGA drivers will not compile on Windows 8 and later versions. If display hardware
is attached to a Windows 8 computer without a driver that is certified to support WDDM 1.2 or later, the
system defaults to running the Microsoft Basic Display Driver.
Display Samples
Purpose Resources
The Windows Driver Kit (WDK) provides a set of tools that Getting Started with Universal Windows Drivers
you can use to develop, analyze, build, install, and test
your driver. The WDK includes powerful verification tools Universal Windows drivers allow developers to create a
that are designed to help you detect, analyze, and correct single driver that runs across multiple different device
errors in driver code during the development process. types, from embedded systems to tablets and desktop
Many of these tools can be used very early in the PCs. Hardware developers can use their existing
development process where they are most critical and can components and device drivers across different form
save you the most time and effort. factors.
Overview Converting WDK 8.1 Projects to WDK 10
The Windows Driver Kit (WDK) is fully integrated with You can convert projects and solutions that you created
Microsoft Visual Studio 2015. The WDK uses the same with WDK 8 or Windows Driver Kit (WDK) 8.1 to work
compiler and build tools that you use to build Visual with Windows Driver Kit (WDK) 10 and Visual Studio
Studio projects. The code analysis and verification tools 2015. Before you open the projects or solutions, run the
can now be easily configured and launched from the ProjectUpgradeTool. The ProjectUpgradeTool converts the
Visual Studio development environment, so that you can projects and solutions so that they can be built using
find and fix problems in your driver source early in the WDK for Windows 10.
development cycle. Validating Universal Windows drivers
The WDK provides a sophisticated driver test framework You can use the ApiValidator.exe tool to verify that the
and a set of device fundamental tests that you can use to APIs that your driver calls are valid for a Universal
automatically build, deploy, and test your driver on Windows driver. The tool returns an error if your driver
remote test systems. The WDK provides the tools to make calls an API that is outside the set of valid APIs for
testing and debugging drivers more convenient and Universal Windows drivers. This tool is part of the WDK
effective than before. for Windows 10.
Driver Development Tools Documentation WDK and Visual Studio build environment
This section describes the tools and techniques that can More information and tips for driver developers about
help you during development: using the WDK and the Visual Studio build environment.
Tools for INF Files Developing, Testing, and Deploying Drivers
For specific information about building drivers, and using
Tools for Changing Boot Options for Driver Testing and the verification tools and tests in the Visual Studio
Debugging development environment.
Tools for Testing Drivers
Tools for Verifying Drivers
Tools for Software Tracing
Additional Driver Tools
Start here to learn fundamental concepts about drivers.

You should already be familiar with the C programming language, and you should understand the ideas of
function pointers, callback functions, and event handlers. If you are going to write a driver based on User-Mode
Driver Framework 1.x, you should be familiar with C++ and COM.
In this section
What is a driver?
Do you need to write a driver?
Choosing a driver model
Write your first driver
Windows compatible hardware development boards
Sharks Cove hardware development board
Provision a computer for driver deployment and testing (WDK 10)
Concepts for all driver developers
Related topics
Windows Driver Kit (WDK)
Driver Security Guidance
GNSS driver design guide
This section contains design guidance for building GNSS device drivers.
In this section
GNSS driver design guide for Windows 8.1
GNSS driver design guide for Windows 10
Related sections
GNSS DDI reference
General-Purpose I/O (GPIO) Driver Design Guide
This section describes how to write a driver for a general-purpose I/O (GPIO ) controller device. A GPIO controller
configures GPIO pins to perform low -speed data I/O operations, to act as device-selects, and to receive interrupt
requests. Starting with Windows 8, the GPIO framework extension (GpioClx) simplifies the task of writing a driver
for a GPIO controller. Additionally, GpioClx provides a uniform I/O request interface to peripheral device drivers
that communicate with devices that connect to GPIO pins on a controller.
In this section
TOPIC DESCRIPTION
GPIO Driver Support Overview Starting with Windows 8, the GPIO framework extension
(GpioClx) simplifies the task of writing a driver for a GPIO
controller device. Additionally, GpioClx provides driver
support for peripheral devices that connect to GPIO pins.
GpioClx, which is a system-supplied extension to the
kernel-mode driver framework (KMDF), performs
processing tasks that are common to members of the
GPIO device class.
GpioClx I/O and Interrupt Interfaces Typically, the clients of a GPIO controller are drivers for
peripheral devices that connect to GPIO pins. These
drivers use GPIO pins as low-bandwidth data channels,
device-select outputs, and interrupt-request inputs.
Peripheral device drivers open logical connections to GPIO
pins that are configured as data inputs or outputs. They
use these connections to send I/O requests to these pins.
In addition, peripheral device drivers can logically connect
their interrupt service routines to GPIO pins that are
configured as interrupt request inputs.
GPIO-Based Hardware Resources Starting with Windows 8, the general-purpose I/O (GPIO)
pins that are controlled by a GPIO controller driver are
available to other drivers as system-managed hardware
resources. GPIO I/O pins, which are pins that are
configured as data inputs or data outputs, are available as
a new Windows resource type, GPIO I/O resources. In
addition, GPIO interrupt pins, which are pins that are
configured as interrupt request inputs, are available as
ordinary Windows interrupt resources.
GPIO Interrupts Some general-purpose I/O (GPIO) controller devices can

configure their GPIO pins to function as interrupt request
inputs. These interrupt request inputs are driven by
peripheral devices that are physically connected to the
GPIO pins. The drivers for these GPIO controllers can
enable, disable, mask, unmask, and clear interrupt
requests on individual GPIO pins.
TOPIC DESCRIPTION
GpioClx DDI The general-purpose I/O (GPIO) controller driver

communicates with the GPIO framework extension
(GpioClx) through the GpioClx device-driver interface
(DDI). This DDI is defined in the Gpioclx.h header file and
is described in General-Purpose I/O (GPIO) Driver
Reference. As part of this DDI, GpioClx implements several
driver support methods, which are called by the GPIO
controller driver. This driver implements a set of event
callback functions, which are called by GpioClx. GpioClx
uses these callbacks to manage interrupt requests from
GPIO pins that are configured as interrupt inputs, and to
transfer data to or from GPIO pins that are configured as
data inputs and outputs.
Hardware notifications design guide
Describes support for key buttons (Power, Windows, volume and rotation lock) and other indicators in a
standardized way, together with associated corresponding Windows Engineering Guidance (WEG ).
In this section
TOPIC DESCRIPTION
GPIO buttons and indicators implementation guide Windows 8 introduced support for general-purpose I/O
(GPIO) buttons and indicators by using a HID miniport class
driver. The goal was to provide support for key buttons
(Power, Windows, volume and rotation lock) in a standardized
way, together with associated corresponding Windows
Engineering Guidance (WEG). Windows 8.1 is focused on
enhancing the quality of the end-to-end user experience and
unifying the behavior across various innovative form factors.
GPIO buttons and indicators supplemental testing This topic describes Windows 8.1 test scenarios for hardware
buttons and indicators, to ensure an optimal user experience
for various form factors.
Hardware notifications support Windows 10, version 1709 provides an infrastructure for the
hardware-agnostic support of notification components such
as LEDs and vibration mechanisms. This support is delivered
through the introduction of a Kernel-Mode Driver Framework
(KMDF) class extension specifically for hardware notification
components that allows for the rapid development of client
drivers. A KMDF class extension is essentially a KMDF driver
that provides a defined set of functionality for a given class of
devices, similar to a port driver in the Windows Driver Model
(WDM). This section provides an overview of the architecture
of the hardware notification class extension. For additional
information about the KMDF, see Using WDF to Develop a
Driver.
Related topics
Hardware notifications reference
HID drivers
This section introduces Human Interface Devices (or HID ). For more information about HID concepts, see the
official HID specification.
In this section
TOPIC DESCRIPTION
What's New in HID
Introduction to HID Concepts This section introduces Human Interface Devices (or HID).
Typically, these are devices that humans use to directly
control the operation of computer systems.
HID Architecture The architecture of the HID driver stack in Windows is

built on the class driver named hidclass.sys.
HID Clients Supported in Windows Windows supports the following top-level collections:
HID Transports Supported in Windows Windows supports the following transports.
HID Clients The HID Clients are drivers, services or applications that
communicate using the HID API and often represent a
specific type of device (for example: a sensor, a keyboard,
or a mouse). They identify the device via a hardware ID or
a specific HID Collection and communicate with the HID
Collection via HID API.
HID Transports Descriptions of HID transports supported in current and

previous versions of Windows.
Non-HID legacy devices This section describes drivers, transports, and filter-drivers
for non-HID keyboards and mice. These devices primarily
run on the PS/2 transport.
IEEE 1394 bus driver design guide
This section includes:

The IEEE 1394 Driver Stack
Installing IEEE 1394 Device Drivers
Asynchronous I/O for IEEE 1394 Devices
Isochronous I/O for IEEE 1394 Devices
Modifying the 1394 Configuration ROM
IEEE 1394 Hardware Emulation Drivers
1394 Samples and Diagnostic Tools
IEC -61883 Client Drivers
Imaging device driver design guide
This section contains information about Windows Image Acquisition (WIA) drivers, Still Image (STI) drivers, and
Web Services on Devices (WSD.)
NOTE
The WIA programming interface is used to develop imaging drivers for modern Windows operating systems. The STI
programming interface was used to develop imaging drivers in legacy Windows operating systems. The STI programming
interface documentation will be archived in a future release.
In this section
Device Interface Classes for Imaging Devices
Windows Image Acquisition Drivers
WIA Properties
64-Bit and WIA
WIA Compatibility Layer
WIA Driver Filters
WIA Item Trees
WIA with Web Services for Devices
Developing a WIA Driver
Developing a WIA Camera Driver
WIA Minidriver Best Practices
WIA Microdriver Commands
Building, Troubleshooting and Debugging WIA Minidrivers
WIA Samples and Tools
Still Image Drivers
Web Services on Devices
Web Services on Devices Reference
Related sections
Imaging DDI reference
File systems driver design guide
This section of the WDK provides conceptual information related to file systems and filter drivers (minifilters). For
information about programming interfaces that your driver can implement or call, see the File System
Programming Reference.
The file systems in Windows are implemented as file system drivers working above the storage system. Each of the
file systems in Windows are designed to provide reliable data storage with varying features to meet the user’s
requirements. A comparison of features for each of the standard file systems in Windows is shown in File System
Functionality Comparison. New for Windows Server 2012 is ReFS. ReFS is a file system with scalable large
volume support and the ability detect and correct data corruption on disk.
Creating a new file system driver in addition to those supplied in Windows is likely unnecessary. File Systems and
File System Filter Drivers can provide any customized behavior required to modify the operation of existing file
systems.
File System Filter Driver Development

A file system filter driver intercepts requests targeted at a file system or another file system filter driver. By
intercepting the request before it reaches its intended target, the filter driver can extend or replace functionality
provided by the original target of the request. Examples of File Systems and File System Filter Drivers include anti-
virus filters, backup agents, and encryption products.
File system filtering services are available through the Filter Manager in Windows. The Filter Manager provides a
framework for developing File Systems and File System Filter Drivers without having to manage all the
complexities of file I/O. The Filter Manager simplifies the development of third-party filter drivers and solves many
of the problems with the existing legacy filter driver model, such as the ability to control load order through an
assigned altitude. A filter driver developed to the Filter Manager model is called a minifilter. Every minifilter driver
has an assigned altitude, which is a unique identifier that determines where the minifilter is loaded relative to other
minifilters in the I/O stack. Altitudes are allocated and managed by Microsoft.
File System Filter Driver Certification

Certification information for File Systems and File System Filter Drivers is found in the Windows Hardware
Certification Kit (HCK). Tests for File Systems and File System Filter Drivers are found in the Filter.Driver category
of the HCK.
File System Filter Driver Developer Resources

To request an altitude allocation from Microsoft, send an e-mail asking for an altitude assignment for your
minifilter. Follow the instructions in Minifilter Altitude Request to submit a request.
To obtain an ID for a filter driver that uses reparse points follow the steps in Reparse Point Request.
You can subscribe to the NTFSD newsgroup for details about developing file systems and filter drivers. The group
is found at NT File System Drivers Newsgroup.
OSR's "Developing File Systems for Windows" seminar explores developing file systems and File Systems and File
System Filter Drivers. See Training for IFS Developers.
This section includes general concepts to help you understand kernel-mode programming and describes specific
techniques of kernel programming. This section is divided into four parts:
Introduction to Windows Drivers provides a general overview of Windows components, lists the types of
device drivers used in Windows, discusses the goals of Windows device drivers, and discusses generic
sample device drivers included in the kit.
Kernel-Mode Managers and Libraries lists the primary kernel-mode components of the Windows operating
system.
Writing WDM Drivers provides information needed to write drivers using the Windows Driver Model
(WDM ).
Driver Programming Techniques describes techniques that you can use to program Windows kernel-mode
device drivers.
Note For information about programming interfaces that your driver can implement or call, see Kernel-
Mode Driver Reference.
Mobile broadband
Use the docs in this section to learn more about mobile broadband and how to configure mobile broadband
experiences for your customers.
Overview
Using metadata to configure mobile broadband experiences
Mobile operator scenarios
Multifunction device driver design guide
A multifunction device occupies one location on its parent bus but contains more than one function. Combination
printer/scanner/fax devices and modem/network cards are common multifunction devices.
In a multifunction device, the individual functions are independent. This means the functions must have the
following characteristics:
The functions cannot have start-order dependencies.
The resource requirements for one function cannot be expressed in terms of the resources of another
function (for example, function1 uses I/O port x and function2 uses port x + 200).
Each function must be able to operate as a separate device, even if it is serviced by the same drivers as
another function.
Additionally, the following requirements must be met so that a multifunction device can be correctly configured on
an NT-based platform:
Each function on the device must be enumerated.
Resource requirements for each function must be communicated to the PnP manager.
There must be INF files and drivers for each function.
The component responsible for each of these tasks depends on the multifunction standard for the device's parent
bus, the extent to which the device conforms to the standard, and the capabilities of the parent bus driver.
If the device complies with the multifunction standards for its bus, your driver requirements are significantly
reduced. Industry-wide multifunction standards have been defined for the PC Card and PCI buses. For the
applicable hardware standards and guidelines, see the multifunction devices Web site.
If you are designing a multifunction printer, please follow the hardware, firmware and software recommendations
available in the Multifunction Printer Design Recommendations white paper.
If you are working with a multifunction DVD/CD -ROM device used for data storage (not for audio/video playback)
on a Windows XP or later operating system, you should use the system-supplied WDM DVD class driver, which
treats the device as a single logical unit. For Windows 2000 and Windows 98, you should treat the device as two
logical units (so it will appear with two drive letters). If the DVD capabilities are combined with some other type of
function, you should treat the device as a single logical unit and supply a class driver that implements common
command sets for all the features of the device. For more information, see the DVD technology Web site.
For a multifunction device that combines other functionality, you can use a system-supplied driver and INF file if
the device complies with the multifunction standards for its bus. The system supplied multifunction driver (mf.sys)
can handle the bus-level enumeration and resource allocation requirements for the device, and the system-
supplied INF (mf.sys) can install the multifunction device. You need to supply only a function driver and INF file for
each of the individual device functions.
If the device does not comply with the standard for its bus, you might need to supply a driver equivalent to mf.sys
in functionality, in addition to function drivers and INF files for the device functions.
To install a multifunction device, you typically provide a base INF file for the device and an additional INF file for
each of the device's functions. The base INF file typically copies the INF files for the device's individual functions.
For information about how to accomplish this, see Copying INFs.
The following sections describe driver and installation requirements for various types of multifunction devices:
Supporting Multifunction PC Card Devices
Supporting Multifunction PCI Devices
Supporting Multifunction Devices On Other Buses
Using the System-Supplied Multifunction Bus Driver
Creating Resource Maps for a Multifunction Device
See INF File Sections and Directives for information about INF file syntax.
The rest of this section describes how to support multifunction devices on Windows 2000 and later NT-based
platforms only.
The Windows Driver Kit (WDK) includes a separate section that describes how to support multifunction audio
devices.
Network Adapter WDF Class Extension
(NetAdapterCx)
Overview
Starting in Windows 10, version 2004, the Windows Driver Kit (WDK) includes a Network Adapter WDF Class
Extension module (NetAdapterCx) that enables you to write a KMDF -based client driver for a Network Interface
Controller (NIC ). NetAdapterCx gives you the power and flexibility of WDF and the networking performance of
NDIS, and makes it easy to write a driver for your NIC.
In previous versions of Windows, WDF and NDIS had individual advantages, but did not interoperate well. The
only way to write a NIC driver was to write an NDIS miniport driver. To use WDF in an NDIS miniport driver, you
had to write extra code in your driver, and even then, you only had access to a small subset of WDF functionality.
With the NetAdapterCx model, conversely, you write a real WDF driver for your NIC. This means that your
NetAdapterCx driver has access to full WDF functionality, as well as networking-specific APIs and I/O support
from the NetAdapter class extension. As shown in the block diagram below, NetAdapterCx still works behind the
scenes with NDIS, but it handles all the interaction with NDIS on your behalf.
Additional info
To watch a video that discusses the benefits of using NetAdapterCx, see the Network Adapter Class Extension:
Overview video on Channel 9.
To learn how to port an NDIS 6.x miniport driver to the NetAdapterCx NIC driver model, see Porting NDIS
miniport drivers to NetAdapterCx.
To start working right away with driver samples on GitHub, clone our NetAdapter-Cx-Driver-Samples repo.
To see the source code for NetAdapterCx itself, or perform step-through debugging, see our Network-Adapter-
Class-Extension repo on GitHub.
If you would like to work with Microsoft as you develop a NetAdapterCx client driver, or have feedback on the class
extension, please send us an email.
To watch a video that discusses the future roadmap and collaboration opportunities, see the Network Adapter
Class Extension: Roadmap and Collaboration video on Channel 9.
Topics
This section contains the following topics:
Porting NDIS miniport drivers to NetAdapterCx
Building a NetAdapterCx client driver
INF files for NetAdapterCx client drivers
Managing the lifetime of objects in NetAdapterCx
Accessing configuration information
Handling control requests
Debugging a NetAdapterCx client driver
Transferring network data
NetAdapterCx receive side scaling (RSS )
Configuring power management
NDIS -WDF function equivalents
NetAdapterCx limitations
Mobile Broadband (MBB ) WDF class extension (MBBCx)
Network Driver Design Guide
This Network Driver Design Guide describes how to design and create network device drivers for Windows
operating systems beginning with Windows Vista.
This guide includes the following sections:
Introduction to Network Drivers
NDIS version guide
NDIS Core Functionality
Scalable Networking
Virtualized Networking
Wireless Networking
Network Module Registrar
Winsock Kernel
IP Helper
Windows Filtering Platform Callout Drivers
System Area Networks
Remote NDIS (RNDIS )
Kernel Mode SDK Topics for Network Drivers
Previous Versions of Network Drivers
Near field communications (NFC) design guide
Windows exposes a rich set of experiences using NFC technology including the following platforms:
Proximity Platform – Provides a platform to initiate peer-to-peer sharing of content between devices via
NFC, focusing on Windows devices, as well as other NFC -compliant mobile devices as well as reading/write
content to/from NFC forum compliant tags.
Wallet Platform – Provides the secure storage and transactional capabilities to power on-device payment
scenarios, as well as brick-and-mortar payments and other NFC transactions.
To enable NFC support, Microsoft relies on IHVs to provide device drivers that implement the Device Driver
Interface (DDI) defined in these topics.
Use the User-Mode Driver Framework (UMDF ) 2.0 to write NFC drivers for Windows 10 for desktop editions
(Home, Pro, Enterprise, and Education) and Windows 10 Mobile.
Related topics
Getting Started with UMDF
NFC device driver interface (DDI) reference
Parallel Device Driver Design Guide

Introduction to Parallel Ports and Devices
System-Supplied Parallel Drivers
Vendor-Supplied Parallel Drivers
Parallel Devices Reference
Partner app development
Partners have the ability to create special use applications for things like the Windows 10 settings app. Some
partner-specific app development scenarios require functionality—such as access to system APIs--that is not
available to APIs with General capabilities. Instead these apps require Restricted or special use capabilities,
allowing for functionality available for partner development in a controlled fashion.
In this section
TOPIC DESCRIPTION
Background tasks and custom triggers for device drivers Learn how to use tasks and triggers in conjunction with your
device drivers and apps.
Create a partner settings app Learn how to create an OEM settings apps for custom
hardware components to help differentiate your brand.
Mobile Broadband Learn more about mobile broadband and how to configure
mobile broadband experiences for your customers.
Wi-fi Direct Learn more about Wi-Fi Direct and the Wi-Fi Direct Services
API in Windows.
PCI driver programming guide
The following table summarizes the PCIe features that are supported by different versions of Windows. For details,
see the specified sections in the official PCIe specification.
FEATURE MINIMUM WINDOWS VERSION
Resizable BAR capability Windows 10

See section 7.22.
Atomic Operations Windows 10

See section 6.15.
ACPI additions for FW latency optimizations Windows 10

See ACPI Additions for FW Latency Optimizations
ATS/PRI Windows 10
ATS specification
Errata for the PCI Express® Base Specification Revision
3.1, Single Root I/O Virtualization and Sharing Revision
1.1, Address Translation and Sharing Revision 1.1, and
M.2 Specification Revision 1.0
Optimized Buffer Flush/Fill (OBFF) Windows 8

See section 6.19. Windows Server 2012
Latency Tolerance Reporting (LTR) Capability Windows 8

Alternative Routing-ID Interpretation (ARI) Windows 8

Message Signaled Interrupt (MSI/MSI-X) Support Windows Vista

See section 6.1.4. Windows Server 2008 R2
TLP Processing Hints (TPH) Windows 8

FEATURE MINIMUM WINDOWS VERSION
Single Root I/O Virtualization (SR-IOV) Windows 8

See Single Root I/O Virtualization (SR-IOV). Windows Server 2012
In this section
PCI Power Management and Device Drivers
Accessing PCI Device Configuration Space
I/O Resource Usage Reduction
Order of Resources in Start-Device IRP
PCI Express FAQ for Graphics
PCI Sample
See Also
Official PCIe specification
PCMCIA Bus Driver Design Guide

Access Attribute Memory of a PCMCIA Device
PCMCIA_INTERFACE_STANDARD Interface for Memory Cards
PCMCIA IRQ Routing on Windows XP
POS device driver design guide
This section provides driver design guidance for point-of-service (POS ) devices.
In this section
TOPIC DESCRIPTION
POS driver samples Provides samples that demonstrate how to create universal
drivers for point-of-service (POS) devices.
Barcode scanner Bluetooth service UUIDs Describes UUIDs for use with the Bluetooth Service Discovery
Protocol (SDP) for barcode scanners.
Barcode scanner events Describes events that are specific to barcode scanners.
Magnetic stripe reader events Describes events that are specific to magnetic stripe readers
(MSRs).
POS events Describes general POS events that are passed from the device
driver to the POS API layer.
Related sections
POS DDI reference
Power Metering and Budgeting Design Guide
This section describes the Power Metering and Budgeting (PMB ) infrastructure and the Power Meter Interface
(PMI).
This section contains the following topics:
Overview of the Power Metering and Budgeting Infrastructure
User-Mode Power Service
Power Meter Interface
Software Defined Batteries
ACPI Power Meter Interface
Printer driver design guide
This section provides information on designing, testing, and debugging printer drivers.
In this section
V4 Printer Drivers
Microsoft Printer Drivers
Printer Driver Overview
Microsoft Universal Printer Driver
Microsoft PostScript Printer Driver
Microsoft Plotter Driver
GDI Printer Drivers
Print Ticket and Print Capabilities Technologies
Writing 64-Bit Printer Drivers
Installing and Configuring Printer Drivers
Printer Configuration
Generic Description Language (GDL )
GDL Reference
GDL Examples
Printer Autoconfiguration
Autoconfiguration Details
Autoconfiguration Implementation Options
Bidirectional Communication
Bidirectional Communication Schema Reference
Bidi Interfaces and Enumerations
Asynchronous User Notification Schema
Web Services for Devices Print Service Schema
Printer Driver Isolation
Customizing Microsoft Printer Drivers
COM Interfaces for Printer Web Pages
Print Pipeline Property Bag
Additional Printer Topics
Print Spooler Components
Printer Driver Testing and Debugging
Related sections
Print DDI reference
SD Bus Driver Design Guide
SD Card Driver Stack

Opening, Initializing and Closing an SD Card Bus Interface
Handling SD Card Interrupts
SD Card Requests
SD Card Hardware Identifiers

For information about Secure Digital (SD ) device identification strings, see Identifiers for Secure Digital (SD )
Devices.
Restrictions on SD Card Drivers

Certain restrictions apply to Secure Digital (SD ) card device drivers that manage a function on an SD combo or
multifunction card. The driver stacks for the various card functions on a multifunction card must operate
independently of one another. To ensure this independence, the bus driver rejects the following operations:
SD commands that change the device state, such as SELECT_CARD.
SD I/O commands that specify function zero but are outside the range of the address specified in the
function basic register (FBR ).
SD I/O commands that specify a function number of a different device stack.
SD device drivers can manage the host controller's common register set and the state of the device by calling
SdBusSubmitRequest with function requests of type SDRF_GET_PROPERTY and SDRF_SET_PROPERTY. For a
description of these function request types, see SD_REQUEST_FUNCTION.
SD Bus Sample
This is a sample for a functional Secure Digital (SD ) IO driver. The driver is written using the Kernel Mode Driver
Framework. It is a driver for a generic mars development board that implements the SDIO protocol without
additional functionality.
Download the Storage SDIO driver sample from GitHub.
Sensor device driver design guide
In this section
What's new in sensor driver development
Overview of the universal sensor driver model
Windows sensor driver features
Programming guide
Sensor driver model for Windows 8.1
Whitepapers
TITLE DESCRIPTION
HID Sensors Usages This paper provides information about the HID Sensor Class
Driver for Windows 8 and later operating systems.
Integrating Ambient Light Sensors with Computers Running This paper provides information about ambient light sensor
Windows 10 Creators Update (ALS) features in the Windows 10 operating system.
Integrating Motion and Orientation Sensors This paper is intended to help OEMs, ODMs, and IHVs
understand motion and orientation sensor capabilities and
requirements for Windows 10 and earlier operating systems.
Related sections
Sensors DDI reference
Sensors Blogs
Serial Controller Driver Design Guide
You can design a driver or application that uses the serial I/O request interface to communicate with a peripheral
device connected to a serial port. A serial port is a hardware communication interface on a serial controller, which
is a 16550 UART or compatible device. To control a serial port to which a peripheral device is permanently
connected, you can design a custom serial controller driver that works with version 2 of the serial framework
extension (SerCx2), which replaces version 1 (SerCx). Or, to control a named serial port located on the case of a
traditional PC, you can use the inbox Serial.sys and Serenum.sys drivers.
In this section
Serial Controller Drivers Overview
Using Version 2 of the Serial Framework Extension (SerCx2)
Using Serial.sys and Serenum.sys
Smart Card Reader Devices Design Guide
Design guide for developing drivers for smart card reader devices.
In this section
TOPIC DESCRIPTION
Smart Card Driver Environment Describes the standard environment for the smart card reader
driver.
Management of IOCTL Requests in a Smart Card Reader Explains how reader drivers manage IOCTL requests, how the
Driver callback routine mechanism works, and what a reader driver
must do to initialize its callback routines.
WDM Reader Driver Lists the routines that are required by a WDM reader driver.
Smart Card Minidrivers The smart card minidriver provides a simpler alternative to
developing a legacy cryptographic service provider (CSP) by
encapsulating most of the complex cryptographic operations
from the card minidriver developer.
Smart Card Reader States A table listing the Smart Card reader states and their
meanings.
Installing Smart Card Reader Drivers Provides installation information that is specific to smart card
reader drivers for Windows.
Registering a WDM Smart Card Reader Driver Provides required registry values and their descriptions for
registering a WDM Smard Card Reader driver.
Enabling Smart Card Event Logging in the Registry Registry value name and contents of the registry value for
event logging.
WDM Device Names for Smart Card Readers Instructions for complying with the naming conventions for
device names in Windows operating systems.
Smart Card Driver Debugging Describes the smart card driver libraries support of debugging
features.
Specifications and Resources To work with the smart card support in Microsoft Windows
operating systems, smart card readers and cards should be
compatible with Interoperability Specification for ICCs and
Personal Computer Systems. Smart card readers and device
drivers should also be Plug and Play compliant.
Simple Peripheral Bus (SPB) Driver Design Guide
This section describes how to write a driver for a simple peripheral bus (SPB ) controller device or for a peripheral
device that is connected to an SPB. The SPB category includes buses such as I²C and SPI. The hardware vendor for
an SPB controller device provides an SPB controller driver to manage the hardware functions in the controller. This
driver might support a family of similar controller devices. The hardware vendor for an SPB -connected peripheral
device provides an SPB peripheral driver to manage the hardware functions in the peripheral device. This driver
might support a family of peripheral devices across a variety of hardware platforms that provide compatible SPBs.
In versions of Windows before Windows 8, the operating system obtained information from SPB -connected
devices on a PC motherboard only indirectly through the platform firmware. Starting with Windows 8, hardware
vendors can supply Windows drivers to directly control their SPB controllers and their SPB -connected peripheral
devices, and to make these devices available for use by the operating system and by applications. For more
information, see SPB Controller Drivers and SPB Peripheral Device Drivers.
SPBs are frequently used to connect low -speed peripheral devices to motherboard chipsets and System on a Chip
(SoC ) modules. An integrated circuit requires fewer pins to connect to a serial bus than to a parallel bus, which
transmits multiple bits of data per clock cycle. Typically, SPBs are used in cost-sensitive applications in which low
pin counts and simple connections are more important than data transmission speed. Because SPBs run at low
speeds and require few electrical connections, they are frequently used in applications in which battery power must
be conserved.
For example, the PC motherboard in a laptop computer might use an I²C bus to communicate with a low -speed
device that monitors the battery level. Similarly, the SoC module in a smart phone or other mobile device might
use an I²C bus to connect to a sensor device, such as an accelerometer, a GPS device, or a temperature sensor.
An SPB is not a Plug and Play bus. Peripheral devices typically have fixed connections to an SPB and cannot be
removed. Even if a peripheral device can be unplugged from a slot on an SPB, the slot is typically dedicated to this
device. During system startup, the ACPI firmware in the hardware platform enumerates the SPB -connected
peripheral devices for the Plug and Play manager, and specifies the hardware resources that are dedicated to each
device.
Included in these resources is a connection ID that identifies the device's connection to the SPB. The connection ID
encapsulates the information (for example, a bus address and a bus clock frequency) that an SPB controller
requires to establish a connection to the device. Other hardware resources might include an interrupt to which the
driver connects its ISR. However, the hardware resources for the device do not include memory for device
registers. An SPB -connected peripheral device is not memory mapped and can be accessed only through the SPB.
For more information, see Connection IDs for SPB -Connected Peripheral Devices.
An SPB provides no bus-specific means to convey interrupt requests from peripheral devices to the processor.
Instead, an SPB -connected peripheral device signals an interrupt through a separate hardware path that lies
outside of both the SPB and the SPB controller. The interrupt service routine (ISR ) for an SPB -connected
peripheral device must run at IRQL = PASSIVE_LEVEL so that it can synchronously send I/O requests to serially
access the hardware registers of the device over the SPB. For more information, see Interrupts from SPB -
Connected Peripheral Devices.
In this section
TOPIC DESCRIPTION
SPB controller drivers An SPB controller is a device that controls a simple peripheral
bus (SPB) and that transfers data to and from the peripheral
devices that are connected to the SPB. The hardware vendor
for an SPB controller provides an SPB controller driver to
manage the hardware functions in the controller.
SPB peripheral device drivers An SPB peripheral device driver controls a peripheral device
that is connected to a simple peripheral bus (SPB). The
hardware registers of this device are available only through
the SPB. To read from or write to the device, the driver must
send I/O requests to the SPB controller. Only this controller
can initiate data transfers to and from the device over the SPB.
Test with Multi Interface Test Tool (MITT) The Multiple Interface Test Tool (MITT) is a test tool for
validating hardware and software for simple peripheral buses,
such as UART, I2C, SPI, and GPIO. MITT uses the FPGA
development board and includes a software package with
firmware, test binaries, and drivers that provide an inexpensive
test solution.
Storage driver design guide
Storage drivers include class, port, miniport, and filter drivers. Typically, a device vendor will implement a miniport
driver for a specific adapter or adapter type. Although not common, a new storage class can be defined and a new
class driver developed for it. Storage classes in Windows include the Disk, CDROM, USB storage, and encrypted
drive classes. Storage driver development is usually limited to writing a miniport driver to work with the StorPort
port driver.
Other types of storage drivers are secure silo drivers and Device Specific Modules (_DSM ) for multipath I/O. For
storage management, WMI providers are developed as a control interface to a driver.
The storage driver design guide includes the following sections:
Roadmap for Developing Windows Storage Drivers
Roadmap for Developing Storport Miniport Drivers
Storage Drivers
Storage Class Drivers
Storage Port Drivers
Storage Miniport Drivers
Storage Virtual Miniport Drivers
Storage Filter Drivers
Crash Dump Filter Drivers
Storage Silo Drivers
CD -ROM Drivers
Tape Drivers
Changer Drivers
Storage Scenarios
Samples
Studying samples is a practical way to see how working storage drivers are developed. Sample storage drivers are
available on GitHub.
Driver Verification for StorPort

Using code analysis tools during driver development and testing helps to catch performance problems and defects
in a storage driver. The Static Driver Verifier (SDV ) tool is available to discover defects in storage driver code.
Included with SDV are compliance rules for verifying proper usage of StorPort routines by miniport drivers.
Streaming media device driver design guide
Use the guidance in this section to design and implement drivers for devices that stream video and audio (for
example, webcams and digital camcorders).
In this section
Device firmware update for USB devices without using a co-installer
USB Video Class (UVC ) camera implementation guide
Frame Server Custom Media Source
360 camera video capture (new for Windows 10, version 1803)
Camera intrinsics
DShow Bridge implementation guidance for UVC devices
Camera class INF file setting for Universal camera drivers (new for Windows 10, version 1709)
USB Video Class (UVC ) driver implementation checklist (new for Windows 10, version 1703)
Camera Device Orientation
AVStream Minidrivers
Windows 2000 Kernel Streaming Model Design Guide
Kernel Streaming Proxy Plug-ins
Streaming Media Samples
OEM guidance on settings for the Windows 10 in-box camera app
Video stabilization registry settings
Extended camera controls (updated for Windows 10, version 1607)
Camera driver bring up guide (new for Windows 10, version 1607)
Universal camera driver design guide for Windows 10
AVStream Property Sets
Broadcast Driver Architecture Property, Event, and Method Sets
Broadcast Driver Architecture Constants
Encoder Property Sets
Encoder Events
AV/C Protocol Driver Function Codes
AV/C Streaming Protocol Driver Function Codes
AV/C Streaming Constants
Video Capture Minidriver Property Sets
Video Capture Minidriver Event Sets
Device transform manager events
Kernel Streaming Topology Nodes
Kernel Streaming Interface Sets
Kernel Streaming Event Sets
Kernel Streaming Method Sets
Stream Class SRB Reference
DVD Decoder Minidriver Property Sets
DVD Decoder Minidriver Event Sets
COM Interfaces
Related sections
Streaming media DDI reference
Test Authoring and Execution Framework (TAEF)
The Test Authoring and Execution Framework (TAEF ) provides a consistent mechanism for developers and testers
to write and run automation. The framework provides a single infrastructure that allows them to share tests across
disciplines and teams.
Universal Serial Bus (USB)
Universal Serial Bus (USB ) provides an expandable, hot-pluggable Plug and Play serial interface that ensures a
standard, low -cost connection for peripheral devices such as keyboards, mice, joysticks, printers, scanners, storage
devices, modems, and video conferencing cameras. Migration to USB is recommended for all peripheral devices
that use legacy ports such as PS/2, serial, and parallel ports.
The USB -IF is a Special Interest Groups (SIGs) that maintains the Official USB Specification, test specifications and
tools.
Windows operating systems include native support for USB host controllers, hubs, and devices and systems that
comply with the official USB specification. Windows also provides programming interfaces that you can use to
develop device drivers and applications that communicate with a USB device.
USB in Windows Write a USB client driver (KMDF, UMDF)

Windows 10: What's new for USB Introduces you to USB driver development. Provides
information about choosing the most appropriate model
Overview of new features and improvements in USB in for providing a USB driver for your device. This section
Windows 10. also includes tutorials about writing your first user-mode
USB FAQ and kernel-mode USB drivers by using the USB templates
Frequently asked questions from driver developers about included with Microsoft Visual Studio.
the USB stack and features that are supported in USB. Getting started with USB client driver development
Microsoft OS Descriptors for USB Devices USB device driver programming reference
Windows defines MS OS descriptors that allows better
enumeration when connected to system running Write a USB host controller driver
Windows operating system If you are developing an xHCI host controller that is not
compliant with the specification or developing a custom
Microsoft-provided USB drivers non-xHCI hardware (such as a virtual host controller), you
USB device-side drivers in Windows can write a host controller driver that communicates with
UCX. For example, consider a wireless dock that supports
A set of drivers for handling common function logic for USB devices. The PC communicates with USB devices
USB devices. through the wireless dock by using USB over TCP as a
USB host-side drivers in Windows transport.
Microsoft provides a core stack of drivers that Developing Windows drivers for USB host controllers
interoperate with devices that are connected to EHCI and
xHCI controllers. USB host controller (UCX) reference
Ucxclass.h
USB-IF device class drivers Ucxcontroller.h
Windows provides in-box device class drivers for many Ucxroothub.h
USB-IF approved device classes, audio, mass storage, and Ucxusbdevice.h
so on.
Ucxendpoint.h
USB generic function driver–WinUSB Ucxsstreams.h
Windows provides Winusb.sys that can be loaded as a
Write a function controller driver for a USB device
function driver for a custom device and a function of a
composite device. You can develop a controller driver that handles all USB
data transfers and commands sent by the host to the
USB generic parent driver for composite devices–Usbccgp device. This driver communicates with the Microsoft-
Parent driver for USB devices with multiple functions. provided USB function controller extension (UFX).
Usbccgp creates physical device objects (PDOs) for each of
those functions. Those individual PDOs are managed by Developing Windows drivers for USB function controllers
their respective USB function drivers, which could be the
Winusb.sys driver or a USB device class driver. USB function class extension (UFX) reference
WDF extension for developing USB drivers Ufxbase.h

USB connector manager class extension (UcmCx) Ufxclient.h
reference Ufxproprietarycharger.h
Ucmmanager.h Write a USB Type-C connector driver
USB host controller (UCX) reference Windows 10 introduces support for the new USB
Ucxclass.h connector: USB Type-C. You can write a driver for the
Ucxcontroller.h connector that communicates with the Microsoft-
Ucxroothub.h provided class extension module: UcmCx to handle
Ucxusbdevice.h scenarios related to Type-C connectors such as, which
Ucxendpoint.h ports support Type-C, which ports support power
Ucxsstreams.h delivery.
USB function class extension (UFX) reference Developing Windows drivers for USB Type-C connectors
Ufxbase.h
Ufxclient.h USB connector manager class extension (UcmCx) reference
Ufxproprietarycharger.h Ucmmanager.h
Testing USB devices with Windows Write a USB dual-role controller driver
Testing USB hardware, drivers, and apps in Windows USB Dual Role controllers are now supported in
Get information about the tools that you can use to test Windows 10. Windows includes in-box client drivers for
your USB hardware or software, capture traces of ChipIdea and Synopsys controllers. For other controllers,
operations and other system events, and observe how the Microsoft provides a set of programming interfaces that
USB driver stack responds to a request sent by a client allow the dual-role class extension (UrsCx) and its client
driver or an application. driver to communicate with each other to handle the role-
switching capability of a dual-role controller.
Read an overview of tests in the Hardware Certification Kit
that enable hardware vendors and device manufacturers For more information about this feature, see:
to prepare their USB devices and host controllers for USB Dual Role Driver Stack Architecture
Windows Hardware Certification submission.
USB dual-role controller driver programming reference
Other Resources for USB
Ursdevice.h
Official USB Specification
Provides complete technical details for the USB protocol. Write a USB driver for emulated devices
Windows 10 introduces support for emulated devices.
Microsoft Windows USB Core Team Blog Now you can develop an emulated Universal Serial Bus
Check out posts written by the Microsoft USB Team. The (USB) host controller driver and a connected virtual USB
blog focuses on the Windows USB driver stack that works device. Both components are combined into a single
with various USB Host controllers and USB hubs found in KMDF driver that communicates with the Microsoft-
Windows PC. A useful resource for USB client driver provided USB device emulation class extension (UdeCx).
developers and USB hardware designers understand the
driver stack implementation, resolve common issues, and Developing Windows drivers for emulated USB devices
explain how to use tools for gathering traces and log files. (UDE)
OSR Online Lists - ntdev Emulated USB host controller driver programming
Discussion list managed by OSR Online for kernel-mode reference
driver developers. Udecxusbdevice.h
Windows Dev-Center for Hardware Development Udecxusbendpoint.h
Miscellaneous resources based on frequently asked Udecxwdfdevice.h
questions from developers who are new to developing Udecxurb.h
USB devices and drivers that work with Windows Write a UWP app
operating systems.
Provides step-by-step instructions about implementing
USB-related videos USB features in a UWP app. To write such an app for a
USB device you need Visual Studio and Microsoft
UWP apps for USB devices Understanding USB 3.0 in Windows Software Development Kit (SDK) .
Windows 8 Building great USB 3.0 devices USB Debugging
Innovations in Windows 8 (Part I, II, & III) Talk to USB devices, start to finish
USB hardware for learning Windows.Devices.Usb
MUTT devices Write a Windows desktop app
MUTT and SuperMUTT devices and the accompanying Describes how an application can call WinUSB Functions
software package are integrated into the HCK suite of USB to communicate with a USB device.
tests. They provide automated testing that can be used
during the development cycle of USB controllers, devices Write a WinUSB application
and systems, especially stress testing. WinUSB functions
OSR USB FX2 Learning Kit Winusb.h
If you are new to USB driver development. The kit is the Usbioctl.h
most suitable to study USB samples included in this
documentation set. You can get the learning kit from OSR Common programming scenarios
Online Store. List of common tasks that a driver or an app performs in
order to communicate with a USB device. Get quick info
about the programming interfaces you need for each task.
USB samples
UWP app samples for USB
Windows driver samples for USB
Development tools
Download kits and tools for Windows
Windows Device Testing Framework (WDTF) design
guide
The Microsoft Windows Device Testing Framework (WDTF ) enables you to create, manage, reuse, and extend
device-centric, scenario-based automated tests.
In this section
TOPIC DESCRIPTION
Writing a WDTF SimpleIO plug-in for your device To get the most benefit from the Device Fundamental tests,
your device should have a Simple I/O plug-in that can perform
simple I/O to your device. This can be one of the default
Simple I/O plugs that come with WDTF or one that you wrote.
To see if your device type is supported and to determine if
there are specific requirements for testing, refer to Provided
WDTF Simple I/O plug-ins.
Writing tests with WDTF Whether you start writing driver tests with the templates
provided in the Windows Driver Kit (WDK), or whether you
create the tests on your own, the Microsoft Windows Device
Testing Framework (WDTF) enables you to create and extend
device-centric, scenario-based automated tests.
Triaging WDTF-based tests To help you better understand what is going on in your
WDTF-based tests, you can use the built-in support for WDTF
Object Logging and WPP Software Tracing.
WDTF Architecture and Overview The Microsoft Windows Device Testing Framework (WDTF)
enables you to create, manage, reuse, and extend device-
centric, scenario-based automated tests.
design guide
This section describes the Windows Hardware Error Architecture (WHEA), which provides support for hardware
error reporting and recovery. In this section, the following information is provided:
An overview of WHEA and its components. For more information, see Windows Hardware Error
Architecture Overview.
How to develop and distribute platform-specific hardware error driver (PSHED ) plug-ins. For more
information, see Platform-Specific Hardware Error Driver Plug-Ins.
How user-mode applications can communicate with the WHEA platform. For more information, see
Windows Hardware Error Architecture-Aware User-Mode Applications.
For more detailed information about WHEA and how to implement WHEA on a hardware platform, see the
WHEA Platform Design Guide. Platform vendors can obtain this design guide by sending email to
[email protected].
In this section
Introduction to the Windows Hardware Error Architecture
New Information for Windows Hardware Error Architecture
Windows Hardware Error Architecture Definitions
Windows Hardware Error Architecture Overview
Platform-Specific Hardware Error Driver Plug-Ins
Windows Hardware Error Architecture-Aware User-Mode Applications
Windows Hardware Error Architecture Debugger Extensions
Related topics
Windows Hardware Error Architecture ACPI Table Specification
Hardware Management and Security
Bug Check 0x124: WHEA_UNCORRECTABLE_ERROR (Windows Debuggers)
Windows Portable Devices
In This Section
WPD Design Guide
WPD Programming Guide
WPD Reference
Windows driver samples
You can browse and download individual Windows 10 driver samples on the Microsoft Samples portal. You can
also clone, fork, or download the Windows-driver-samples repo on GitHub.
Earlier versions of Windows driver samples are archived at Microsoft Archive on GitHub:
Windows 8.1 driver samples
Windows 8 driver samples
For Windows 7, samples were included in the Windows Driver Kit (WDK).
Driver samples for specific technologies

For more information about the Windows 10 driver samples available for a specific technology area, see the
following topics:
Audio driver samples
AVStream driver samples
Battery driver samples
Biometrics driver samples
Bluetooth driver samples
File system driver samples
General driver samples
General-purpose input/output (GPIO ) driver samples
Global Navigation Satellite System (GNSS ) driver samples
Human interface devices (HID ) driver samples
Input driver samples
Networking driver samples
Near field communication (NFC ) driver samples
Near field proximity (NFP ) driver samples
Power framework (PoFx) driver samples
Point of service (POS ) driver samples
Print driver samples
Secure Digital (SD ) driver samples
Security driver samples
Sensor driver samples
Serial driver samples
Setup samples
Smart card driver samples
Simple peripheral bus (SPB ) driver samples
Storage driver samples
Thermal driver samples
Tools samples
Trusted Execution Environment (TrEE ) driver samples
Universal Serial Bus (USB ) driver samples
Video driver samples
Windows Image Acquisition (WIA) driver samples
Windows Management Instrumentation (WMI) driver samples
Windows Portable Device (WPD ) driver samples

Driver

Uploaded by

Copyright:

Available Formats

Driver

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Driver

Uploaded by

Copyright:

Available Formats

Contents

Getting Started with the Windows Driver Kit

DRIVER 1903 1809 1803 1709 1703 1607 1507

What's new in driver development for Windows 10

Driver Templates discoverability

Windows Hardware Dev Center dashboard

NEW TOPICS UPDATED TOPICS

!ioctldecode command New command capabilities in the dx (Display Debugger Object

Debugging in Windows 10, version 1607

For more info, see Target platform on driver reference pages.

What's new in Windows 10, version 1903 (latest)

What's new in Windows 10, version 1809

What's new in Windows 10, version 1803

What's new in Windows 10, version 1709

CALLBACK FUNCTIONS STRUCTURES

Synchronized system QPC with USB frame and microframes

What's new in Windows 10, version 1607

What's new in Windows 10, version 1507

DRIVER TECHNOLOGY FEATURE DEPRECATED IN

Mobile Operator Scenarios AllowStandardUserPinUnlock Windows 10, version 1709

WDK for Windows 10, version 1903

Step 1: Install Visual Studio 2019

Step 2: Install WDK for Windows 10, version 1903

EWDK with Visual Studio Build Tools

Windows 10 Windows Server 2019, Windows Server 2016

Windows 8.1 Windows Server 2012 R2

Windows 8 Windows Server 2012

Windows 7 Windows Server 2008 R2 SP1

Universal Windows driver samples

Install Windows Driver Kit (WDK) Insider Preview

reg add HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\StrongName\Verification\*,31bf3856ad364e35 /v TestPublicKey /t

reg add HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\StrongName\Verification\*,31bf3856ad364e35 /v

3. Install SDK Insider Preview

Install Enterprise WDK (EWDK) Insider Preview

Run-time requirements for the WDK and the EWDK

Windows 10 Windows Server 2016

Windows 8.1 Windows Server 2012 R2

Windows 8 Windows Server 2012

Windows 7 Windows Server 2008 R2 SP1

Step 1: Install Visual Studio

TARGETED VERSIONS OF WINDOWS EDITION(S) OF VISUAL STUDIO

Windows 10, version 1809 Visual Studio Community 2017

Windows 8.1 Update Visual Studio 2013

Windows 8 Visual Studio Professional 2012

Windows 10, version 1703 Windows SDK for Windows 10.0.15063.468

Windows 10, version 1607 Windows SDK for Windows 10.0.14393.795

Windows 8.1 Windows SDK for Windows 8.1

Windows 8 Windows SDK for Windows 8

Step 2: Install the WDK

VERSIONS OF WINDOWS WDK AND RELATED DOWNLOADS

Windows 8.1 Update WDK 8.1 Update (English only)

Windows 8 WDK 8 (English only)

Windows XP WDK 7.1.0

Optional: Install the EWDK

VERSIONS OF WINDOWS EWDK

Optional: Install updated test certificates for HAL extensions

Optional: Install WinDbg Preview

Standalone tools for debugging Windows XP and Windows Vista

Hardware dashboard API