Add support for MTP device class

[roundby]

Describe the PR
Add Media Transfer Protocol (MTP) device class support

Additional context
Feature request reference: #1079

The implementation has been tested and found functional at prototype level. We provide an example tested on STM32F3. It makes use of blulk and interrupt EPs only, so it should be supported by most platforms.

The class supports a single session only, but it allows multiple objects and nested associations (i.e. files and folders). We did not add support for object properties access. There are some other limitations but for the purpose of exposing file trees when mass storage class is not advised, the library is fully functional.

This implementation has been written from the ground up, with minimal requirements on buffers and keeping the code as simple as possible. Most of the buffer allocation for object I/O is demanded to the underlying implementation, as such, the RAM footprint of the library is limited.

The working mechanism of MTP (persistent 32 bit file handles) may not scale well on microcontrollers with constrained resources, depending on the application requirements. In the example, we just provide a fixed filesystem with files residing in RAM. It would be possible, depending on the application requirements, to build filesystem based I/O on top of this, by using the API provided in mtp_device.h.

The sources are available here

[WerWolv]

Congrats!
I started working on my own MTP driver about a week ago and just got the first few things working now before I found your PR. Nowhere near done yet but here's my branch in case it helps anybody: https://github.com/WerWolv/tinyusb/tree/sicd

[roundby]

@WerWolv thank you for sharing!
I am giving some context here, as it might be beneficial for review. I had a short look at your code, the implementation is not that far from the one we're suggesting. Since you already have a hands-on experience on how the MTP class works, it would be great if you could take a look at our code too (feel free to add comments or propose corrections) and maybe perform a test on a physical device (since now, we tested it on STM32F3 and on a custom PSoC5LP port, on Windows hosts). Hopefully, the example should work out of the box on most of the already supported demo boards.

This code has been designed after the need to expose a set of files and folders stored in an SPI memory managed by littlefs, and we took the chance to do it within this library (we already used TinyUSB on some of our designs, and we hope this is a way to contribute back). While reading the code and the example, one should remind that the specification requires the device to provide a session unique 32 bit identifier for each object (e.g. file or directory), cached by the host when traversing storage content, able to be recalled any time and never re-used if an object is deleted. The implementation of this on the application side and in case of static files is easy, but it's not trivial on mutable file system where file I/O is performed by both host and (internally) by the device. Moreover, we found that, under Windows (appearing in contrast with MTP requirements) the object IDs are still cached if the session is closed and reopened, unless a bus reset or physical unplug is performed.

Comparing with your code:

• mtp.h contains some of the definitions you have in sicd.h. We added packed data structures for fixed data as we found this easier to read and similar to what is already done (see mass storage device class).
• We provided application callbacks in mtp_device_storage.h, in order for the application to provide the interface to enumerate, read and write objects. Comments should be self-explanatory, but feel free to ask in case of doubts.
• mtp_device.c contains the actual implementation (similar to your sicd_device.c). We did not require a minimum EP size, as the buffer I/O is managed by the application (usually the filesystem itself), but we statically allocated a single buffer with size MTP_MAX_PACKET_SIZE (512). With this single buffer, the code supports arbitrary object sizes. Each command is handled in a single function and information is taken from tud_mtp_* callbacks.
• The example code is under examples/device/mtp/src/mtp_fs_example.c. A few MTP class specific definitions, namely CFG_MTP_*, are added to tusb_config.h.
• We did not add support for properties (we don't need them, and they would have increased the amount of code to review).

The code is functional, and it is expected to be ready for exposing file and directory level I/O when a block device is not advisable:

• Storage is visible in Explorer
• Objects (files and directories) can be enumerated
• Object reading, creation and deletion works

I recognize that the introduction of a new class (and it's the first time we're contributing to TinyUSB) could require some time for a review and refinement, so, we'll wait for indications from the maintainers about the interest in merging this, asking for changes, moving to a different branch for testing/integration with additional features or any other suggestion. So far, we corrected all the notified build errors and most of the code scanning notices.

[simon88]

Hi @roundby
Great work, do you try it with littlefs?