I keep "Essential Linux Device Drivers" on my desk, next to a bunch of other Linux kernel programming books: "Linux Device Drivers" by Rubini, "Linux Kernel Internals" by Beck et. al. (which is a bit outdated), "Embedded Linux" by Hollabaugh, "Building Embedded Linux Systems" by Yaghmour, "Understanding Linux Network Internals" by Benvenuti.

"Essential Linux Device Drivers" is the best one yet, followed by Rubini's as a closed second. Between these two books alone, you can learn how to write any device driver from scratch - if handed the hardware manual. But "Essential Linux Device Drivers" goes deeper, and has more real life code examples.

The code in "Essential Linux Device Drivers" has obviously been copied from real development projects, and I found no errors in it. I've looked carefully at the networking driver code, serial driver code, i2c driver code, and kernel thread/interlocking/timer primitives.

There are some suggestions I have (and this applies to all Linux books I've read). One is to make clear that the spin_lock_irqsave() API should be used instead of spin_lock() whenever it may be called from interrupt context. Second is to explain how the interrupt routine stack space is created at the bottom of the regular (thread) stack space.

Overall, good job, Mr. Venkateswaran! You've helped me a lot with my driver code. The $44.99 I paid was well spent on your book.

The people who gave this book 5 starts are either friends of the author, the author himself, or guys who have been writing linux drivers for years and felt like reading what they already knew. Although the author seems to be very knowledgeable on the topic, his book is really terrible at explaining the essential kernel functions needed for writing device drivers and their respective parameters. He only mentions that they exist. To understand what the author is doing, you would have to resort to searching alternate references. Also his examples don't work. I can tell that he never tried to compiled these examples.

After reading the first few chapters, I decided to get the linux device drivers book from O'REILLY and as soon as I started reading, I could point out loads of important information that the first book failed to relay. The examples in the O'REILLY book are also by far better.

Like other reviews have stated, this first half of this book is a concise, useful introduction to certain Linux kernel concepts. But the title of the book leads the reader to expect that they could produce a Linux device driver using this book. That turns out not to be the case - no one could produce a driver with this book without the benefit of other reference material. In short, while the O'Reilly "Linux Device Drivers" text has it's shortcomings and is starting to become dated, it is still the only text with which the reader can use as a primary reference to create their own driver. It discusses implementation in detail, which this book does not.

This brings me to the second half of "Essential Linux Device Drivers", where specific device types are discussed. So little time is spent on each type that none are covered in enough detail to actually go off and start a driver of that type. You could be thinking that this book never claimed to enable you to write a PCI driver, for example, and that would be true. It just feels like a reduced scope with increased depth on the remainder would have made a much more useful book, rather than a bathroom reader.

This book is intended to teach an intermediate level programmer who is already proficient in the "C" language to write device drivers for the Linux operating system. The book covers Linux kernel 2.6-23/24 versions which just happens to be the version I was using with my Ubuntu 8.04 laptop at the time of my review.

The author is clearly an experienced device driver programmer and he has a first rate command of written English. I found his writing to be clear, well organized and most importantly capable of teaching me how to work with kernel sources that are actively in use. He does an excellent job of explaining the environment in which modern device drivers will be used and he covers all of the major categories of devices that a programmer would need. This book thoroughly covers these categories in enough detail to get the programmer started writing drivers. I particularly liked his mentioning several source code analysis tools that are commonly used by those having to work with kernel sources. At least
two of the tools, cscope and ctags, I used when working on kernel maintenance on another UNIX platform. These tools made it possible to browse through the symbols used in the kernel and also to allow one to see where the corresponding name was declared and where it was accessed (read or written).

The author gives a high level explanation of each driver type covered and then helps the reader navigate the relevant source code files in the kernel source tree.

I was also pleasantly surprised to find that the author had more than a passing aquaintance with embedded Linux having participated in a number of driver projects for embedded Linux devices. As you might expect in a book on device drivers the author describes the major routines used for a class of device drivers,
where the routine can be found (file/tree structure), a full explanation of how the routines are used and the functions they perform. The author presents the reader with device driver code for devices that would need drivers and also shows how they would be integrated into the existing device driver structure
for the class of device presented.

The final chapters of his book describe user space device drivers, miscellaneous device drivers (ACPI, Firewire etc). He has an excellent chapter on debugging device drivers which covers kernel debuggers, kernel probes as well as kernel exec and kdump. He offers a sample debugging section for a buggy driver. He also covers kernel execution profiling and tracing.

The book index is well done allowing the reader to quickly pinpoint items of interest. Book indexing is to some extent an art form and Prentice Hall does an especially good job with their technical books.

Overall I'd give this book a high rating and it's good enough that I will add a copy to my personal
library.

This book is really good for anyone who wants to delve into Linux Device Driver development.Every topic is explained in simple plain english with appropriate code examples. And the best thing is that every thing right from a simple char driver to the complex PCMCIA and wireless drivers have been explained so we get all the help that we need for developing various kind of device drivers just at a single place. The things that appeared to be so complex and hard to understand previously have now started making sense.This book is sort of pratical guide. The only improvement that I would suggest is the complex nesting of various kernel structures and the drivers code should be explained in diagramatical form first. Apart from that it would be nice if the source code examples provided in the book can be downloaded from its website.