Table of Contents
If you use UIO for your card's driver, here's what you get:
only one small kernel module to write and maintain.
develop the main part of your driver in user space, with all the tools and libraries you're used to.
bugs in your driver won't crash the kernel.
updates of your driver can take place without recompiling the kernel.
Each UIO device is accessed through a device file and several
sysfs attribute files. The device file will be called
/dev/uio0
for the first device, and
/dev/uio1
, /dev/uio2
and so on for subsequent devices.
/dev/uioX
is used to access the
address space of the card. Just use
mmap()
to access registers or RAM
locations of your card.
Interrupts are handled by reading from
/dev/uioX
. A blocking
read()
from
/dev/uioX
will return as soon as an
interrupt occurs. You can also use
select()
on
/dev/uioX
to wait for an interrupt. The
integer value read from /dev/uioX
represents the total interrupt count. You can use this number
to figure out if you missed some interrupts.
To handle interrupts properly, your custom kernel module can provide its own interrupt handler. It will automatically be called by the built-in handler.
For cards that don't generate interrupts but need to be
polled, there is the possibility to set up a timer that
triggers the interrupt handler at configurable time intervals.
This interrupt simulation is done by calling
uio_event_notify()
from the timer's event handler.
Each driver provides attributes that are used to read or write variables. These attributes are accessible through sysfs files. A custom kernel driver module can add its own attributes to the device owned by the uio driver, but not added to the UIO device itself at this time. This might change in the future if it would be found to be useful.
The following standard attributes are provided by the UIO framework:
name
: The name of your device. It is
recommended to use the name of your kernel module for this.
version
: A version string defined by your
driver. This allows the user space part of your driver to deal
with different versions of the kernel module.
event
: The total number of interrupts
handled by the driver since the last time the device node was
read.
These attributes appear under the
/sys/class/uio/uioX
directory. Please
note that this directory might be a symlink, and not a real
directory. Any userspace code that accesses it must be able
to handle this.
Each UIO device can make one or more memory regions available for memory mapping. This is necessary because some industrial I/O cards require access to more than one PCI memory region in a driver.
Each mapping has its own directory in sysfs, the first mapping
appears as /sys/class/uio/uioX/maps/map0/
.
Subsequent mappings create directories map1/
,
map2/
, and so on. These directories will only
appear if the size of the mapping is not 0.
Each mapX/
directory contains two read-only files
that show start address and size of the memory:
addr
: The address of memory that can be mapped.
size
: The size, in bytes, of the memory
pointed to by addr.
From userspace, the different mappings are distinguished by adjusting
the offset
parameter of the
mmap()
call. To map the memory of mapping N, you
have to use N times the page size as your offset:
offset = N * getpagesize();