Source code driver

Active 10 years, 10 months ago. Viewed 13k times. Improve this question. Michael Kniskern Hick Hick Add a comment. Active Oldest Votes. Improve this answer. Roddy Roddy Bar none, the only reference required. Doug T. Why the downvote? I like how the style matches the question's. Because it's not considered helpful , I think. It has a strong introductory section on Linux and how device drivers generally work.

Linux Device Drivers The "standard" with a free pdf link as mentioned by others Understanding the Linux Kernel The longer you spend here, the better you need to really understand the kernel. Jun 10, Jul 2, Driver signing changes for driver samples Apr 23, Use SHA signing in fakemodem project. Jun 14, Aug 21, Sep 25, Apr 16, Apr 27, Jun 24, Update sensors drivers Feb 5, Adding sha driver signing to additional driver samples Change simbatt sample to sign with sha instead of sha1 Mar 5, Updating the smartcard pscr project to use SHA Oct 27, Jun 2, The high level driver simply manages the file system itself and where to put things.

It then communicates where it wants to read or write from the disk to the lower level driver which may or may not talk directly to hardware.

There may be another layer which then communicates that request to the actual hardware driver which then physically reads or writes a particular sector off a disk and then returns it to the higher level. It could then determine what sector read requests to service, however, it has no idea what the data is and does not interpret it.

The first thing you will notice is the DbgPrint function. This data structure contains basically three entries. The first is the size of the current Unicode string, the second is the maximum size that the Unicode string can be, and the third is a pointer to the Unicode string. This is used to describe a Unicode string and used commonly in drivers. Most Unicode strings passing into your driver will not be NULL terminated, so this is something you need to be aware of.

Devices have names just like anything else. The second parameter we passed 0, and it says to specify the number of bytes to create for the device extension. This is basically a data structure that the driver writer can define which is unique to that device.

This is how you can extend the information being passed into a device and create device contexts, etc. We will not be using this for this example. These requests are called IRP Major requests. There are also Minor requests which are sub-requests of these and can be found in the stack location of the IRP.

What do these refer to? When communicating with the user-mode application, certain APIs call directly to the driver and pass in parameters! So as you can see, when a user mode application uses these functions, it calls into your driver.

That is true, these APIs can talk to any device which exposes itself to user mode, they are not only for accessing files.

In the last piece of this article, we will be writing a user mode application to talk to our driver and it will simply do CreateFile , WriteFile , CloseHandle. You can technically omit this function but if you want to unload your driver dynamically, then it must be specified.

If you do not specify this function once your driver is loaded, the system will not allow it to be unloaded. We are simply setting the flags. I will explain this in the section on handling user-mode write requests. However, if you create a device in any function outside of the DriverEntry , you need to manually clear this flag for any device you create with IoCreateDevice. This flag is actually set by the IoCreateDevice function.

The last piece of our driver is using both of the Unicode strings we defined above. To put this into perspective, different vendors have different drivers and each driver is required to have its own name. You cannot have two drivers with the same NT Device name. Say, you have a memory stick which can display itself to the system as a new drive letter which is any available drive letter such as E:. If you remove this memory stick and say you map a network drive to E:. How is this possible?

Well, the driver needs to be able to interpret the requests and either handle them within themselves such as the case of a network redirector or pass them down to the appropriate hardware driver. This is done through symbolic links. E: is a symbolic link. This is how applications can be written using a commonly defined name which can be abstracted to point to any device driver which would be able to handle requests.

We can do whatever we wish to do, but in the end, however, the application attempts to use the device as how the device driver needs to respond and act. The next piece of code we will look at is the unload routine. This is required in order to be able to unload the device driver dynamically.

This section will be a bit smaller as there is not much to explain. You can do whatever you wish in your unload routine. If this article is liked, I may write a second tutorial on implementing the IO Control function. If you have used WriteFile and ReadFile , you know that you simply pass a buffer of data to write data to a device or read data from a device.

These parameters are sent to the device in the IRP as we explained previously. The entry point simply provides the device object for the device for which this request is being sent for.

If you recall, a single driver can create multiple devices even though we have only created one. The other parameter is as was mentioned before which is an IRP! In our example, the only parameter we need from this is the length of the buffer provided to the driver, which is at Parameters. This is a description of the user mode addresses and how they map to physical addresses. This operation will then give us a system virtual address which we can then use to read the memory.

The reasoning behind this is that some drivers do not always process a user mode request in the context of the thread or even the process in which it was issued. If you process a request in a different thread which is running in another process context, you would not be able to read user mode memory across process boundaries.

So, this simply maps the physical pages used by the user mode process into system memory. We can then use the returned address to access the buffer passed down from user mode. This method is generally used for larger buffers since it does not require memory to be copied. As mentioned above, the idea is to pass data down to the driver that can be accessed from any context such as another thread in another process. The other reason would be to map the memory to be non-paged so the driver can also read it at raised IRQL levels.

The reason you may need to access memory outside the current process context is that some drivers create threads in the SYSTEM process. They then defer work to this process either asynchronously or synchronously. A driver at a higher level than your driver may do this or your driver itself may do it. This is now overhead in processing every read and write into the driver.

This is one of the reasons this is best used on smaller buffers. The other problem with using this for larger buffers is that since it allocates non-paged memory, it would need to allocate a large block of sequential non-paged memory.

In this method, the driver accesses the user mode address directly. The upside of this is that no data is copied, no memory is allocated, and no pages are locked into memory. The downside of this is that you must process this request in the context of the calling thread so you will be able to access the user mode address space of the correct process.

The other downside of this is that the process itself can attempt to change access to the pages, free the memory, etc. These directives you see simply let the linker know what segment to put the code and what options to set on the pages. This is because you only need that function during initialization.

You can use the Write routines as reference to figure out what you need to do. A lot of tutorials will go and explain the registry, however, I have chosen not to at this time. There is a simple user mode API that you can use to load and unload the driver without having to do anything else. This is what we will use for now. This code will load the driver and start it. It will not start automatically on boot, that way we can test it, and if we blue-screen, we can fix the issue without having to boot to safe mode.

This program will simply pause. Include in your project the driver files of the sensor. When using the supported STMicroelectronics evaluation boards, the example file. The complete list is provided here. Add the STMicroelectronics sensor driver to your project.

Add the example source file. Add the call to the example function inside the while 1 loop in your main function. Skip to content.