The goal: Building a Linux embedded camera
The problem: Supporting a large number of sensors with an even large number of registers and properties
Currently, the SOC framework in the more recent kernel versions addresses this in a smart way: a generic SOC v4l2 framework serves as a base for custom sensor support kernel modules that register their ioctls and generic v4l2 properties with this framework.
This intelligent approach still has one drawback:
- It enlarges the kernel even more
- Access of sensor properties needs to be coded manually
How to break the gordian knot? This is a sketch of an idea.
The netpp library allows to create abstract property lists from XML description files. These files describe a device in general, there can be a low level section specifying register addresses and an abstract property section linking property names (strings) to registers or bits. The XML code is translated into a compact property list of C structs and compiled into object code.
Now, we don’t want this stuff living in kernel space, right? We’d rather want some kind of callback functionality so that only the common denominator of all functionality is handled in kernel space.
Example: An embedded camera must handle several sensors even at the same time, possibly via bus tristating or on several video input channels.
This would require major efforts with the current model.
The proposed alternative:
- A sensor kernel module handles only detection of a sensor type and the bus type methods (e.g. i2c). This would be a very thin layer, thus easy to implement.
- Basic v4l2 functionality (like setting resolution) can be encoded in this driver as ioctl() handlers, if necessary
- Preferrably, the more exotic ioctls or specific device properties that were so far handled by custom ioctls are now living in user space.
- User space applications using these sensors register their sensor property lists via a kernel daemon. This daemon handles the callbacks from a kernel ioctl() to a user space property.
Cons:
- The total overhead may be increased, as the user application contains all the netpp description (C code, not XML) blurb.
- User space code can do forbidden stuff, of course. Permissions must be sorted out well, extra checks for exploits must be taken care of.
Pros:
- Only generic code in Kernel
- Most flexibility for multi head or pluggable camera hardware
- Little development overhead required: Sensor properties are just encoded in a readable (style sheet capable editors!) XML source format.
- It is up to the user which properties are exposed or hidden.
Explore:
- What’s the optimum callback mechanism (hotplug/dbus?)
- Do we want more interaction between netpp and the kernel daemon?
- Do we want a very generic property netpp daemon?
- Do we even want enhanced remote property control (RPC) functionality
Comments are closed.