May 16, 2019
Introducing cmtp-responder - a permissively licensed Media Transfer Protocol (MTP) responder implementation which allows embedded devices to provide MTP services and supports a core set of MTP operations.
MTP is an accepted way of exposing storage capability of embedded devices. The host involved in MTP communication is called an MTP Initiator, while the device is called an MTP Responder. This post is about one such MTP Responder.
Although MTP does not enforce underlying transmission medium, a predominant approach is to utilize USB and this post is about MTP using USB for data transport.
There are other ways to expose storage capability of an embedded device, such as USB Mass Storage, but the latter requires an underlying filesystem. On the other hand, with MTP, the exposed contents is not enforced to even reside on any filesystem - it is sufficient for an MTP-compliant device to provide a listing of available files and folders in such a way that each entity can be uniquely identified and to provide means of transferring the entities between a host and the device. These characteristics make MTP attractive for device makers. And indeed, for example virtually all modern Android devices do provide MTP as the primary means to expose their storage capabilities.
Here comes the problem we intend to solve: there is no MTP implementation available which would provide at least basic functionality, introduce as little dependencies as possible and whose license would allow using it for various purposes. There is a piece of software called uMTP-responder and while it covers well the first two requirements, it is provided under GPLv3 terms which might be a problem in some applications. On the other hand, software such as buteo-mtp is permissively licensed, but it is written in C++ (might or might not be an issue) and introduces dependency on qt and buteo sync framework.
People have been trying to upstream in-kernel mtp implementation but for various reasons those patches have not been accepted.
Yes, you can!
That is exactly the rationale for our cmtp-responder project.
That being said, we haven't started from scratch. There is a permissively licensed (Apache 2.0) mtp-responder implementation in Tizen. It is written in C. While we appreciate the work Tizen has put into creating mtp-responder, we must acknowledge that the original Tizen's code is hard to reuse, because it depends on a lot of Tizen-specific libraries. We forked it to make cmtp-responder depend only on generic libraries (glib-2.0 and systemd). This of course implies removing all the Tizen-specific features. The source code of cmtp-responder can be found here.
The purpose of cmtp-responder is to provide a reusable minimal MTP implementation for everyone to reuse. The long-term goal is to make this project the implementation of choice for a variety of projects, including commercial products, and make this project as feature-complete as possible while maintaining generality and minimal dependencies.
At the time of this writing cmtp-responder supports these basic functionalities:
In particular, at the time of this writing cmtp-responder does not support renaming the entries in its "store" and editing them in place - you can, however, overwrite an existing item with new contents from the host.
cmtp-responder is designed to be used on top of systemd. It uses underlying storage located in a selected folder of the device filesystem. For interacting with the kernel it uses FunctionFS - please see this post to learn about using FunctionFS.
We have tested cmtp-responder with both Linux and Windows hosts and it seems it is ready to play with it, hence this release announcement.
Below are your instructions.
The source code is located here. You can clone it the usual way.
cmtp-responder can be built both for x86_64 and for armhf hosts.
To build for x86_64 issue
cmake CMakeLists.txt followed by
To cross-compile for armhf you need to have your cross-compilation environment available. Covering how to prepare such an environment is beyond the scope of this post. One of your options is to have multiarch correctly set up. Then you need to issue
PKG_CONFIG_PATH=/usr/lib/arm-linux-gnueabihf/pkgconfig/ cmake -DCMAKE_TOOLCHAIN_FILE=armhf-toolchain.txt followed by
Please note that in both cases you need glib-2.0 and systemd development libraries for the chosen architecture installed. On debian-based systems they are called libglib2.0-dev and libsystemd-dev.
In the post you can read more about FunctionFS USB descriptors and strings. To have cmtp-responder's build system generate those for you you need to add
-DCMAKE_BUILD_DESCRIPTORS=1 to cmake invocation. The result will be
strs files in the toplevel source directory for USB descriptors and strings, respectively. This will work only when compiling for x86_64 host!
In the systemd directory in the source tree there are example systemd unit files needed to make cmtp-responder work and a scheme file for the gt tool needed to compose the USB gadget. Adapting the instructions found in the post to the needs of deploying cmtp-responder is left as an excercise to the readers.
Did you know you could run a permissively-licensed MTP implementation with minimal dependencies on an embedded device? Here's a step-by-step…
Earlier this year, the Rust compiler gained support for LLVM source-base code coverage. In this post we'll explain how to setup a CI job…
Over the past few months, I've been working on a side project to improve Meson sub-project support. The best stress test is to build projects…
The most complete automated testing and continuous integration tool for the Linux kernel continues to evolve at a rapid pace. Here's a look…
In the embedded world, many modern SoCs such as the ST Microelectronics STM32MP1 now include coprocessor cores which can be used for a wide…
Our recent efforts on the Hantro kernel driver have resulted in the addition of H.264 decoding support and multiple performance improvements.…