driver writing != bus driving : Drivers (General)

A study guide for KMDF, UMDF, and Windows device driver concepts

iliast — Sun, 28 Sep 2008 11:33:00 GMT

One of the most common question that beginner driver developers ask is how they can start learning about driver development. Today, Eliyas, my manager, pointed out that we have already created a study guide that covers WDF and general Windows device driver concepts. It can be found here. I think that this self-study guide is really helpful and covers the important points that a driver developer should be accustomed with.

Driver Developer Conference - DDC 2008

iliast — Fri, 26 Sep 2008 08:26:00 GMT

Next week (9/29 - 10/1) we'll have the Microsoft Windows Driver Developer Conference (DDC) in Redmond. We're expecting several driver developers. I'm excited about this, not only because it's the first time that I'll be participating in a Microsoft conference, but also because I'll be giving a talk! Indeed, Bob Kjelgaard and I are giving a talk titled "Packaging and Deploying KMDF and UMDF drivers". Actually, a better name for the talk would be "Everything technical that you ever wanted to know about the WDF coinstallers and were afraid to ask" (yes, I actually requested to have this title, however it didn't go through :) ). I think that right now the information that's externally available for the coinstallers is pretty limited. Actually, apart from the fact that "they are coinstallers and you need to have them with all your WDF drivers" and a few posts that Bob and I have written, I don't think that anything else is known about them. In our talk we'll try to show lots of light into this part of WDF.

The last several days we've been practising our talk and I'm pretty happy about it. There is enough technical information in the talk to explain all the common questions that people have and also there will be enough time in the end to answer all sorts of questions that might arise from the presentation. Also, we'll both be available to answer questions in the "Ask The Experts" session, in the panel discussion for WDF and of course we'll be talking to customers and partners in the corridors and in the halls, in order to answer the questions that they might have. I've been teasing Bob by telling him that I'll forward all the hard questions to him, however I've been really happy to work with Bob for such a long time. He's definately a really technical person and he's explaining all these advanced techniques of testing different parts of the framework that blow me away :)

Apart from our talk, there will be a series of presentations for WDF. I've actually sat through all the dry runs of the talks and I think that we have excellent material to present (yes, I know that it's kind of weird to praise the team that I'm part of, but I really believe it). I won't try to write down all the WDF presentations, however you can look at the agenda and the descriptions.

So, for those of you, who are coming to DDC and are interested in the WDF coinstallers, please come with all your questions and we'll be happy to answer them as best as we can!

Channel9 Video on Debugging BSODs

iliast — Sun, 14 Sep 2008 22:33:00 GMT

I found a very interesting channel9 video on how to debug BSODs (Blue Screens of Death): http://channel9.msdn.com/posts/Dan/Daniel-Pearson-Debugging-a-Windows-Blue-Screen-of-Death/

Daniel Pearson explains why blue screens happen in Windows, how a user can find the cause and how Driver Verifier works. Also, in the end he talks a little bit about how to debug applications and he shows a neat trick with notepad :)

Developing Windows Drivers With Visual Studio

iliast — Wed, 30 Jan 2008 01:44:00 GMT

Today morning I received an email from Patrick with a picture of Visual Studio with Intellisense on a WDF driver. Ok, I have to admit that in the beginning I thought that Patrick was using Photoshop! He's a guy, who just doesn't like GUIs in the first place! He can just go on and on about the advantages of using kd instead of windbg! He even refuses to look at the source code (even if it's available), since "he can look at the assembly"! I have to admit that until now I thought that he was doing "copy con driver.c" to write drivers... and then use edit.com from a full-screen command prompt to do additional editing. Anyway, it seems that I was wrong.

So, in order to be sure that Patrick hadn't used Photoshop (or just opened the screenshot with a hex editor and manually edited it, in order to add Intellisense!), I went to his office. Over there, indeed he showed me that it's really easy to Intellisense and help integration to Visual Studio (yay!). That's nice stuff! My next question was, if it's possible to load wudfext.dll (the UMDF windbg extension) from Visual Studio and use the UMDF extensions from the VS debugger, however it's not possible (even though there's some info on how to load windbg extensions at http://www.osronline.com/showThread.cfm?link=66160), because not all windbg interfaces are implemented by Visual Studio.

Anyway, Patrick has written a post saying that indeed he's been using Visual Studio for ever, in order to develop Windows Drivers. If more people ask him tips on how to make VS the best editor for Windows Drivers, he promised that he'll share a small part of his infinite wisdom :) So, feel free to ask him and/or send him an email!

DISCLAIMER: Visual Studio is not officially supported by Microsoft for driver development. The only currently supported build environment is the command window that comes with the WDK. Any opinions expressed in this article don't affect Microsoft's policy on this issue.

Driver-Driver and Driver-Application Communication

iliast — Sun, 07 Oct 2007 01:06:00 GMT

Everybody knows how an application communicates with a driver: call CreateFile to open a handle to the PDO, and use ReadFile(Ex), WriteFile(Ex) and DeviceIoControl to read data, write data or send a control code.

However, what about the opposite? How does a driver send data to an application (whenever it wants)? And how do drivers exchange data? These types of questions come very often in OSR's NTDEV list, so I found a list of resources that provide answers:

Driver-Driver Communication

Driver to Driver Communication: Explanation of the way that drivers exchange data between each other

Buddy Drivers: An implementation of 2 drivers exchanging data

Driver-Application Communication

Peter Wieland has written this post on how the driver uses the Push or the Pull model to send data to an application

Inverted Call Model: An implementation of Peter's model that shows how the driver sends data to the application

Sharing memory between drivers and applications: Why, when and how?

Driver-Application communication using IRQs

OSR's thread on Driver-Application communication: Many driver developers write down their opinions on this issue

Microsoft's documentation: How to use asynchronous events, in order to send data from a driver to an application

UMDF drivers

How an application communicates with a UMDF driver:Overview of the WDK sample that is located at %WinDDK%\src\umdf\usb\fx2_driver\final

How Driver Installation Works

iliast — Sat, 06 Oct 2007 23:59:00 GMT

The last few months I've been working on the WDF 1.7 (UMDF+KMDF) coinstallers (that's one of the reasons that I've been silent for quite some time).

Through this process I managed to learn a lot of things about how driver installation works and what is required by the driver developer. Unfortunately, this area is often a black box for driver developers, since their job ends, after the driver is up and running (and hopefully tested :) ). However, it's possible that you might want the driver installation to do something "more", e.g. change the icon of the device in the device manager or add a page in the device manager that shows the driver capabilities, etc. This is when a coinstaller or a class installer is needed.

Let's start from the beginning though. If you have a driver, then how do you install it? The easy way is OSR's Driver Loader. Just point to your sys file, click "Register Service" (i.e. create the appropriate settings in the registry at HKLM\System\CurrentControlSet\Services\<Driver Name>) and "Start Service" (i.e. call the Service Control Manager APIs that load the driver according to the registry settings). If you want to remove the driver, just click on "Stop Service" (stops the driver from running) and "Unregister Service" (deletes the registry settings). Easy, right? You don't need an inf file or anything more apart from your driver. However, this program supports non-pnp (legacy) drivers only.

For WDF drivers we provide a coinstaller (one for UMDF and one for KMDF). The main tasks of the coinstaller is to upgrade the framework (e.g. from 1.5 to 1.7), parse the inf file and configure the driver correctly. In the past, we've had some issues with the previous versions of the coinstallers, as shown by Bob Kjelgaard (part 1, part 2, part 3), however we're trying our best to tackle them. By the way, if you have any problems with the installation of a WDF driver, please look at the Doron's post for information on how to debug it and at Bob's post for information about how you can ask more help from Microsoft.

Microsoft has lots of useful information on Driver Installation at http://www.microsoft.com/whdc/driver/install/default.mspx, however I'd also like to point specifically to:

Eugene Lin and Jason Cobb's channel9 video: Introductory overview on how the user-mode Plug-and-Play manager works and how the installation works from the point that the device is connected to the machine, until the corresponding driver is selected and the device is running
Jim Cavalaris' presentation on coinstallers and class installers: Excellent presentation that shows how the class installers and the coinstaller cooperate during driver installation. Also look at the resources, which are provided at the last page.
Debugging Device Installation on Windows Vista: Everything that you wanted to know (and even more than that!) about how to debug problems during device installation (and were afraid to ask)
Device Installation Design Guide: Microsoft's official documentation on everything that has to do with device installation

Windows Development Videos and Presentations

iliast — Tue, 31 Oct 2006 13:15:00 GMT

WHDC has a very nice page that with many presentations and videos about driver development at http://www.microsoft.com/whdc/driver/foundation/DevNotes.mspx

You'll find there 9 videos about WDF, 3 about KMDF, and 2 about kernel debugging, as well as many presentations. There is no video for UMDF, yet :( For those of you, who prefer looking at videos instead of reading documentation, this site should be really helpful :)

A few other pages that is not easy to find are WinHEC 2004 and WinHEC 2005. From the main WHDC website, somebody can find directly only the material for WinHEC 2006 conference papers and presentations. WinHEC stands for WINdows Hardware Engineering Conference and is a conference, in which Microsoft presents the newest directions regarding hardware development and drivers (mostly).If somebody is interested in buying the DVD from one of the Microsoft events (WinHEC, PDC, TechEd, etc), he should look here.

UPDATE:

The WDF videos from the WHDC link provide a very complete and easy to understand introduction to WDF, focusing on KMDF. Since in that site they are not shown with the same order that the were presented in WinHEC 2004, I'll give the links in order:

UPDATE 2:

Another site with many videos is http://www.microsoft.com/seminar/mmcfeed/mmcdisplay.asp?lang=en&pf=100502. For example, you'll be able to find there many videos from WinHEC 2002. There are some interesting videos there, like the "General Driver: Windows Driver Power Management" (you can also compare this presentation with the WDF presentations on Power Management from the WHDC website), and the "General Driver Understanding Driver Security" presentations by Adrian Oney, the presentations on PnP, etc.

Finally, Microsoft also offers webcasts on-demand in the website http://www.microsoft.com/events/webcasts/ondemand.mspx. I think that particularly interesting are the ones related to security that can be specifically found by going to the "Webcast Series" and clicking on the "Digital Blackbelt Series".

Windows Device Drivers Book Reviews

iliast — Thu, 26 Oct 2006 03:18:00 GMT

A quick search in the web reveals that the number of the books that are related to windows device drivers can be counted with the fingers of one hand. Even worse, most of the books are either too old (published before or around windows 2000) and/or not easily readable. Another problem is that the Windows Driver Model (WDM) is becoming more complex as time passes, so the newer books are relatively more complex to read than the older ones.

Based on all of this and after looking at different book reviews, I decided to read a few books that make it easier for a beginner to get an insight on driver development.

So, I think that the best book to start with regarding driver development is Windows NT Device Driver Development (OSR Classic Reprints) (original version was published in 1997) by Peter G. Viscarola and W. Anthony Mason. This book is divided into 3 parts. The first part (chapters 1-8) talk about Windows internals fundamental concepts, like HAL, scheduling, virtual memory, registry, etc. The second part (chapters 9-20) is the bulk of the book and talks about the development of device drivers. Actually, this can be further subdivided into chapters 8-10, which talk about the I/O manager, 11-17, which is the core part of the book (DriverEntry, Dispatch routines, Interrupt Service Routines, Deffered Procedure Calls, Programmed I/O and DMA), and chapters 18-20, which talk about building and debugging a driver. Finally, chapters 21-24 talk about alternate NT driver architectures, like File system drivers, SCSI drivers, Video miniport drivers and NDIS (network) miniport drivers. I think that there are both advantages and disadvantages in this book. I'll start with the advantages:

It's very easy to read. It starts with very fundamental stuff, builds on top of them and explains the concepts in an easy-to-understand way. This is really to hard to find in the rest of the books. Possibly the fact that both writers teach driver development courses make it easier for them to understand what questions and problems a beginner driver developer might have, so they try to answer them in front.
It focuses on explaining the concepts and doesn't present pages and pages of un-understandable code. It just presents the functions, explains how they work and shows a cumulative example that shows the use of a few functions bundled together.
It's a short book (the first 20 chapters take less than 550 pages) and has small chapters. I think that this fine grain analysis helps the reader. I like the fact that I can read a few small chapters within a day and then pickup the book the next day (or a few days later) without breaking my reading in the middle of the chapter and trying to remember what the first part of the chapter was saying.

Of course, the book has also some disadvantages:

It doesn't cover plug-n-play, power management and other WDM concepts. This is normal, since the book covers NT drivers and not WDM drivers.I haven't found many outdated parts of the book (i.e. almost everything that is written in the book applies even for WDM drivers in Windows XP), apart from the fact that the DriverEntry chapter (chapter 13) talks a lot about manually finding the resources (memory+I/O) that the driver should be using, whereas for WDM drivers this is done automatically. It also doesn't cover Physical Device Objects (PDOs), Function Device Objects (FDOs) and Filter Device Objects (FiDOs), since they didn't exist at that time.
The examples are small and after understanding the concepts, it's nice to be able to look at some code that will explain them.

So, in order to solve the disadvantages of the first book, I think that the solution is to read The Windows 2000 Device Driver Book: A Guide for Programmers (2nd Edition) (published in 2000) by Art Baker and Jerry Lozano. The strengths of this book are exactly those above:

The book covers Windows 2000 drivers, so it covers Power Management, Plug-n-Play, Windows Management Instrumentation (WMI) and many WDM concepts that were not covered by the first book.
The book is full of examples. The writer also provides the source code in the accompanying cd-rom, so it's easy to build them and learn from the source.
Again, the book is easy to read and short. I like a lot compact books that stick to the topic and don't provide stuff that distract the reader. This book is one of those. The whole book is around 400 pages, so it can be finished quite quickly.

So, after finishing both these books and playing with the source code (and with the source code that can be found in the WDK or elsewhere in the net), I think that the next step is to read Programming the Microsoft Windows Driver Model, Second Edition (published in 2002) by Walter Oney. Again, this book has both advantages and disadvantages. This time, I'll start with the disadvantages :) :

This book is definately NOT for beginners. I consider it hard to understand and it considers way too many things as known.
I don't like the structure of the book very well. For example, even though the author mentions that the first 7 chapters are fundamentals and the rest go deeper, he puts the I/O control operations after the plug-n-play or the power management. Of course, this is a personal view, however I was overwhelmed, when I managed to reach the 6th chapter. The first 3 chapters are very good, however I think that after that the difficulty grows exponentially, at least for a beginner.
The material presented in the book is very dense, so a lot of stuff is presented within a small number of pages and then you look at a big code listing that should explain everything. As I said above, I prefer a slower approach that goes step by step and builds on top of fundamental concepts.
I don't think that the book gives a a clear high-level view of what a device driver is composed of (I'll explain this below). I had the feeling that the author explains one thing, then the next and the next, but it's hard to understand how everything fits together and how all of these components are related.

On the other hand, this book has some advantages that cannot be covered by any other existing book:

It is the newest book, so it provides the best picture about the current version of the Windows Driver Model (WDM).
It's the only book that covers Windows XP, so it's the only choice for somebody, who wants to take advantage of this platform.
I think that each section is described more deeply than from the rest of the books.

Finally, I think that such a review would be incomplete, if I didn't refer to Microsoft Windows Internals, Fourth Edition: Microsoft Windows Server(TM) 2003, Windows XP, and Windows 2000 (Pro-Developer) (published in December 2004) by Mark E. Russinovich and David A. Solomon. This book doesn' t talk directly about writing device drivers, but it talks about windows internals in general. Some of them are covered in the above mentioned books, however this book is the newest of all and provides the most in-depth analysis. Also, chapter 9 is devoted specifically to the I/O manager and to windows device drivers, so it's definately worth to read. I especially like one particular section in chapter 9 that is titled "Structure of a Driver" and gives a high-level overview of all the components of a driver. That's exactly an important thing that is missing from Walter Oney's book and is not clearly explained in the rest of the books. So, according to the book, a windows device driver is composed of:

An initialization routine: This function is named DriverEntry (for WDM drivers) and is called by the I/O manager only once, when the driver is initially loaded. It is used by the driver to initialize its internal (global) structures.
An add-on device routine: This function is named AddDevice and is called by the I/O manager, whenever a new device, for which the driver is responsible, is detected. It is used by the driver to initialize the device object (i.e. the internal structure) that corresponds to the newly-found device.
A set of dispatch routines: These are the functions that are called by an application (or another driver) to communicate with the device. They include functions like read, write, open, close, control, etc. When called to perform an I/O operation, the I/O manager creates an IRP (I/O Request Packet), which is a structure that descibes the request, and sends it to the driver.
An Interrupt Service Routine (ISR): One of the ways that an external device can communicate with the CPU is through interrupts (the other way is polling, but let's forget about it for now). So, whenever the device wants to communicate with the CPU, it sends an interrupt to the CPU and the CPU executes some code that needs to serve the device (e.g. find if the device finished some calculation or received a packet, etc and find what to do afterwards). The code that is executed is called the Interrupt Service Routine (ISR). Therefore, the driver that controls the device needs to implement this ISR.
Deffered Procedure Call (DPC): Whenever an ISR is executing, the IRQL (IRQ Level) of the CPU is high, so all the interrupts that have lower IRQL than the current interrupt cannot be served. In order to solve this problem, drivers perform only very basic calculation in their ISR and for the rest of the processing they schedule a DPC. This function executes in a low IRQL (which is named DISPATCH_LEVEL), so that the rest of the interrupts can be serviced. Therefore, the DPC can be considered as just an extension to the ISR (they serve the same purpose, but they execute at different IRQL). Of course, a driver can execute DPCs not only from an ISR, but from any other function, however this is the main use of a DPC.
A start I/O routine: Some drivers wants to process the incoming I/O requests serially, i.e. one at a time. Therefore, they ask the I/O manager to queue the incoming IRPs. This function is used to initiate the next data transfer to or from the device.
One or more I/O completion routines: Sometimes a driver, which receives an I/O request does some processing and passes the IRP to the next driver in the stack, without finalizing the IRP processing (finalizing means that the I/O operation was completed successfully, failed or cancelled). The I/O completion routine informs the driver that another driver in the stack has marked the I/O as "finalized", so the current driver's I/O completion routine can be called, in order to perform some cleanup operations.
A cancel I/O routine: This function is called, when the I/O manager wants to cancel the processing of an IRP. This function mostly releases any resources that were acquired during the processing of the IRP and it also marks the IRP as "cancelled". Not all IRPs can be cancelled, though.
An unload routine: The I/O manager calls this routine, when it wants to unload the driver from memory. The drives releases any resources that it might have acquired.
A system shutdown notification routine: The I/O manager calls this routine, when the system is about to shutdown.
Error-logging routines: Whenever an error occurs, the driver uses these routines to log the error and notify the I/O manager.

Here I would like to note that all the above books are for the Windows Driver Model. As I've mentioned many times before, Microsoft is changing the driver model for Windows Vista. However, there aren't any books for the Windows Driver Foundation (WDF - the new windows model) yet. The only public announcement for such a book is the Introduction to the Windows Driver Foundation - Kernel Mode Driver Framework by Peter Viscarola, Tony Mason, Mark Cariddi, Brenda Ryan, Scott Noone, and OSR.

Hardware and Driver Developer Blogs + Driver tips

iliast — Sun, 08 Oct 2006 05:10:00 GMT

Thanks, to craigrow, I saw that Microsoft has created a list for hardware and driver developer blogs. I'm still not there yet, but I hope that this will change :)

Another interesting link are the driver tips, which include papers about driver synchronization, memory management, driver design, debugging, etc.

A Comparison of the Linux and Windows Device Driver Architectures

iliast — Wed, 04 Oct 2006 02:00:00 GMT

While searching for something irrelevant, I found a very interesting paper, called "A Comparison of the Linux and Windows Device Driver Architectures" by Melekam Tsegaye and Richard Foss. It was published at the ACM Operating Systems Review, Volume 38, Number 2, 2004. You can find a link to the paper here.

The paper compares the device driver architectures between linux and windows. It starts by providing an extensive analysis to both architectures and then presenting a detailed comparison. The paper covers the 2.4 linux kernel and the Windows Driver Model (WDM) from Windows XP, so it can be considered that it is quite up-to-date (at least from the Windows perspective). Also, in the same page, you'll find Melekam Tsegaye's MSc Thesis, which covers the same contents as the paper, but it also presents the design and the implementation of an IEEE-1394 driver for both windows and linux. Both drivers can be found here, while the presentation of the thesis can be found here.

Key Driver Concepts and Driver Development books

iliast — Mon, 02 Oct 2006 23:28:00 GMT

While looking at the traffic at the OSR ndev mailing list I saw that some introductory questions are answered in Microsoft's Key Driver Concepts page. The links in this page include (but are not limited to) information about:

Synchronization primitives (mutexes, fast mutexes, semaphores, spinlocks, etc)
Memory management
Windows scheduling
C vs C++ as a language for driver development
User-Mode Interactions: Guidelines for Kernel-Mode Drivers
Recommended Functions for Kernel-Mode Drivers
Cancel Logic in Windows Drivers
How to Port WDM Drivers to KMDF
and many more...

Also, I would like to like to provide a brief list of the most popular books for development of windows device drivers:

Programming the Microsoft Windows Driver Model, Second Edition by Walter Oney (2002): The latest (and possibly the most complete) book on drivers. It covers all Plug-n-Play drivers in detail.
The Windows 2000 Device Driver Book: A Guide for Programmers (2nd Edition) by Art Baker and Jerry Lozano (2000): A classic book for windows device drivers, however it's definately showing its age. It covers the WDM model for Windows 2000 and is short in legnth (less than 500 pages) compared to the rest of the books
Writing Windows Wdm Device Drivers: Covers Nt 4, Win 98, and Win 2000 by Chris Cant (1999): Another relatively short in length easy to read book that is currently outdated, since it covers earlier versions of windows.
Windows NT Device Driver Development by Viscarola and Mason, published by New Riders (1998, reprint in 2006): (Copying from OSR's website) Written by OSR's consulting partners, this book contains the details about the NT I/O subsystem. The only disadvantage of this book is that it was written in the NT V4 timeframe, before Win2K and therefore before the introduction of Plug and Play support. No matter, it's still the most solid architectural reference around.
Developing Windows NT Device Drivers: A Programmer's Handbook by Edward Dekker and Joseph Newcomer (1999): It is a thick (over 1200 pages), extensive and verbose books that covers every aspect of Windows device drivers. You can find a review here.

Finally, for those curious/interested to learn about windows NT's history, I would like to point out the book Show Stopper! Cloth: THE BREAKNECK RACE TO CREATE WINDOWS NT AND THE NEXT GENERATION AT MICROSOFT by Pascal Zachary (1994). It is a short (around 300 pages), easy-to-read book that describes both Windows NT's creation by David Cutler (chief architect), and Microsoft's culture. The book is out of print, but it's definately worth reading.

Introductory driver writing resources

iliast — Fri, 29 Sep 2006 23:49:00 GMT

After having finished with the initial resources on the windows internals, it is time for a developer to start learning about windows drivers. The goal of this post is to provide a list of links that can be used by somebody to get accustomed with the idea of a driver, the tools that he needs to use, etc.

A very important url for this case is http://www.osronline.com. At the top of that page it says "Everything (About) Windows Driver Development" and this is (almost :) ) the case. In fact, this site has a lots of resources that are really useful both to new and to more experienced developers. The first thing that I suggest that you should do, after visiting this website is to become a member (by clicking on the "Join" button). Membership is free and it gives you access to a lot of additional helpful resources:

First of all (and maybe most important for now) you'll find a list of "fundamental" resources at http://www.osronline.com/section.cfm?section=26. This list is consisted of several interesting subjects, like Getting Started with Windows Drivers (which is the very first document that you should read, in order to get answers to lots of your questions about drivers), Exactly what is a Driver (which gives a simple technical overview of a driver) and also some basic information about what are the threads, the rings, page fault and real mode (even though I hope that you've learned these by looking at the resources that I mentioned in my previous posts).
Another important link in the website is the listserv. There are 3 lists that are being maintained by OSR: ntdev (various windows system-level topics), windbg (windows debugger or windbg is a really important tool for driver debugging) and ntfsd (file systems and file system filter drivers). The range of the members in these lists is pretty wide, from beginners to veterans. MOST IMPORTANTLY, there are many Microsoft employees, who participate actively in the list and answer the questions. All of the lists are a MUST-join (especially the 2 first ones, if you are not interested in file system drivers).
Apart from the above very important links there are some more like the NT Insider (similar to an online magazine that covers articles relative to driver development), Downloads (includes many useful utilities like the Driver loader) and Hector's Memos (another interesting blog about driver development).

In addition, Microsoft also offers a lot of really valuable resources:

By clicking here, you'll get redirected to an article that provides all the introductory information that you need about drivers: types of drivers, development environment, debugging tools (windbg rocks!), etc. It's more technical than the corresponding OSR paper, but it remains an all-encompassing easy-to-read paper.
All the current windows drivers (excluding the legacy ones) are written in a way that is called the Windows Driver Model (WDM). However, the new model (from Windows Vista and afterwards it is the default model, however there will be versions for previous operating systems, too) is the Windows Driver Foundation (WDF). This model is much much simpler than WDM and is the model that will be used for drivers in the future (i.e. that's the model that a new driver developer should become accustomed with!). This model allows both the creation of kernel-mode and user-mode drivers. The former framework is called Kernel-Mode Driver Framework (KMDF) and you can find an introduction here. The latter framework is called User-Mode Driver Framework (UMDF) and you can find an introduction here. Also, the UMDF Beta, which includes sample code, documentation, development tools, etc can be downloaded from here.
Another very useful website with videos from Microsoft employees is http://channel9.msdn.com/. I think that the most interesting videos for driver developers are the ones in the "Going Deep" series and the ones marked with the "Drivers" tag. Some interesting relevant topics are (I'll try to update this list int the future):

Windows Vista's internal architecture by Rob Short (corporate vice president)
Windows I/O manager part 1 by Nar Ganapathy (architect)
Windows I/O manager part 2 by Nar Ganapathy (architect)
Windows Vista I/O by Nar Ganapathy (architect)
User-Mode Driver Framework by Peter Wieland (UMDF Dev Lead)
Kernel-Mode Driver Framework by Doron Holan (KMDF Dev Lead)
PreFAST for Drivers by Donn Terry (Software Developer)
I/O cancellation (whole team)

The Windows Driver Kit (try visiting the link with IE), which is an all-in-one driver development kit. It is the definitive source for driver development, since it includes Microsoft's public documentation about the driver model, as well as all the public APIs. The information in the WDK is relatively easy to read (up to a point). I suggest that you read "Getting started with Windows Drivers" and the "Kernel-Mode Driver Architecture Design Guide" (As much as possible. Most of the information there should be familiar after reading the Windows Internals book, too). After that, depending on the type of the driver that you are interested in (kernel-mode or user-mode) you should look at the "Kernel-Mode Framework Design Guide" or the "User-Mode Framework Design Guide" respectively. The former is more complete, but I think that the latter is written in a more simple style. Generally, the WDK is a valuable reference, so you can also find available tools, installation techniques, etc. Peter Wieland has written a post with extensive instructions on how to download the WDK (warning: it's 2.3GB!), which will allow you to take advantage of the development environment, the samples, etc.
The public Microsoft newsgroups can be found at the newsgroup server msnews.microsoft.com (you'll need a newsgroup reader like Outlook Express to read them). The most important ones are Microsoft.pulbic.development.device.drivers, Microsoft.public.win32.programmer.kernel and Microsoft.public.windowsxp.device_driver.dev.

Prerequisites for a driver developer

iliast — Thu, 28 Sep 2006 21:00:00 GMT

If somebody wants to build a solid house, he needs to have a solid foundation. That's why, if somebody wants to become a good driver developer, he needs to be familiar with some fundamental computer science terms. At minimum, he needs to know the basics about operating systems, computer architecture and computer networks.

The easiest way to become familiar with these concepts is to take undergrad computer science courses on operating systems and computer networks. In case somebody is unable to do this or if he wants to refresh his knowledge, I can point out to a few links from universities that offer online recorded relevant courses:

1)Operating systems from the University of Notre Dame: http://www.cse.nd.edu/~surendar/teach/spr06/cse30341/lecture.shtml
2)Computer networks from Carnegie Mellon University: http://www.cs.cmu.edu/~srini/15-441/S05/
Of course, there are many relevant links in the internet, however these are the only 2 links that I know of, which offer the videos of the lectures online for free (please feel free to write down more, if you know).

Finally, I would like to mention that the University of Washington offers a list of useful graduate courses (e.g. computer architecture, databases, etc), whose lectures can be viewed online: http://www.cs.washington.edu/education/dl/course_index.html

For the rest of the blog, I'll consider that the basic terms as known (e.g. What is a driver? What is an I/O port? etc) and that I won't have to explain them.