kernel driver or user space driver?

2
votes

I would like to ask your advice on the following: I need to write drivers for omap3, for accessing external dsp through fpga (through gpmc interface). The dsp is required to load file to dsp, and to read/write buffer from dsp. There is already FPGA driver in kernel. The kernel is 2.6.32. So I thought of the following options:

writing dsp driver in kernel, which uses the existing fpga driver.

writing a user space driver which interfaces with the fpga kernel driver.

writing user space driver using UIO , which will not use the kernel fpga driver, but shall do the access to fpga, as part of the user space single and complete dsp driver.

What do you think is prefered option ? What is the advantage of kernel driver over user sace and vise versa ?

Thanks, Ran

1
linuxkerneldriver

1 Answers

4
votes

* User-space driver:

  • Easier to debug.
  • Loads of libraries to support you.
  • Allows you to hide the details of your IP if you want to ( people will really hate you if you did! )
  • A crash won't affect the whole system.
  • Higher latency in handling interrupts since the kernel will have to relay the interrupt to the user space somehow.
  • You can't control access to your device from user space.

* Kernel-space driver:

  • Harder to debug.
  • Only linux kernel frameworks are supported.
  • You can always provide a binary blob to hide the details of your IP but this is annoying since it has to be generated against a specific kernel.
  • A crash will bring down the whole system.
  • Less latency in handling interrupts.
  • You can control access to your device from kernel space because it's a global context that all processes see.

As a kernel engineer I'm more comfortable/happy hacking code in a kernel context, that's probably why I would write the whole driver in the kernel.

However, I would say that the best thing to do is to divide the functionality of your driver into units and only put the unit in the kernel when there's a reason to do so.

For example:

  • If your device has a shared resource ( like an MMU, hardware FIFO ) and you want multiple processes to be able to use it safely, then probably you need some buffer manager to be in the kernel and all the processes would be communicating with it through ioctl.
  • If your driver needs to respond to an interrupt as fast as possible ( very low-latency ), then you will need to put the part of the code that handles interrupts in the kernel interrupt handler rather than putting it in user space and notifying user space when an interrupt occurs.