Add MTP class device

4 files changed, 990 insertions, 0 deletions

diff --git a/examples/device/mtp/src/main.c b/examples/device/mtp/src/main.c
new file mode 100644
index 000000000..709aeb16f
--- /dev/null
+++ b/examples/device/mtp/src/main.c
@@ -0,0 +1,113 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "bsp/board_api.h"
+#include "tusb.h"
+
+//--------------------------------------------------------------------+
+// MACRO CONSTANT TYPEDEF PROTYPES
+//--------------------------------------------------------------------+
+
+/* Blink pattern
+ * - 250 ms  : device not mounted
+ * - 1000 ms : device mounted
+ * - 2500 ms : device is suspended
+ */
+enum {
+  BLINK_NOT_MOUNTED = 250,
+  BLINK_MOUNTED = 1000,
+  BLINK_SUSPENDED = 2500,
+};
+
+static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
+
+void led_blinking_task(void);
+
+/*------------- MAIN -------------*/
+int main(void) {
+  board_init();
+
+  // init device stack on configured roothub port
+  tusb_rhport_init_t dev_init = {
+    .role = TUSB_ROLE_DEVICE,
+    .speed = TUSB_SPEED_AUTO
+  };
+  tusb_init(BOARD_TUD_RHPORT, &dev_init);
+
+  if (board_init_after_tusb) {
+    board_init_after_tusb();
+  }
+
+  while (1) {
+    tud_task(); // tinyusb device task
+    led_blinking_task();
+  }
+}
+
+//--------------------------------------------------------------------+
+// Device callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when device is mounted
+void tud_mount_cb(void) {
+  blink_interval_ms = BLINK_MOUNTED;
+}
+
+// Invoked when device is unmounted
+void tud_umount_cb(void) {
+  blink_interval_ms = BLINK_NOT_MOUNTED;
+}
+
+// Invoked when usb bus is suspended
+// remote_wakeup_en : if host allow us  to perform remote wakeup
+// Within 7ms, device must draw an average of current less than 2.5 mA from bus
+void tud_suspend_cb(bool remote_wakeup_en) {
+  (void) remote_wakeup_en;
+  blink_interval_ms = BLINK_SUSPENDED;
+}
+
+// Invoked when usb bus is resumed
+void tud_resume_cb(void) {
+  blink_interval_ms = tud_mounted() ? BLINK_MOUNTED : BLINK_NOT_MOUNTED;
+}
+
+//--------------------------------------------------------------------+
+// BLINKING TASK
+//--------------------------------------------------------------------+
+void led_blinking_task(void) {
+  static uint32_t start_ms = 0;
+  static bool led_state = false;
+
+  // Blink every interval ms
+  if (board_millis() - start_ms < blink_interval_ms) return; // not enough time
+  start_ms += blink_interval_ms;
+
+  board_led_write(led_state);
+  led_state = 1 - led_state; // toggle
+}
diff --git a/examples/device/mtp/src/mtp_fs_example.c b/examples/device/mtp/src/mtp_fs_example.c
new file mode 100644
index 000000000..41673ea53
--- /dev/null
+++ b/examples/device/mtp/src/mtp_fs_example.c
@@ -0,0 +1,572 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "class/mtp/mtp_device_storage.h"
+#include "tusb.h"
+
+#define MTPD_STORAGE_DESCRIPTION "storage"
+#define MTPD_VOLUME_IDENTIFIER "volume"
+
+//--------------------------------------------------------------------+
+// RAM FILESYSTEM
+//--------------------------------------------------------------------+
+#define FS_MAX_NODES 5UL
+#define FS_MAX_NODE_BYTES 128UL
+#define FS_MAX_NODE_NAME_LEN 64UL
+#define FS_ISODATETIME_LEN 26UL
+
+typedef struct
+{
+    uint32_t handle;
+    uint32_t parent;
+    uint32_t size;
+    bool allocated;
+    bool association;
+    char name[FS_MAX_NODE_NAME_LEN];
+    char created[FS_ISODATETIME_LEN];
+    char modified[FS_ISODATETIME_LEN];
+    uint8_t data[FS_MAX_NODE_BYTES];
+} fs_object_info_t;
+
+// Sample object file
+static fs_object_info_t _fs_objects[FS_MAX_NODES] = {
+    {
+        .handle = 1,
+        .parent = 0,
+        .allocated = true,
+        .association = false,
+        .name = "readme.txt",
+        .created = "20240104T111134.0",
+        .modified = "20241214T121110.0",
+        .data = "USB MTP on RAM Filesystem example\n",
+        .size = 34
+    }
+};
+
+//--------------------------------------------------------------------+
+// OPERATING STATUS
+//--------------------------------------------------------------------+
+typedef struct
+{
+    // Session
+    uint32_t session_id;
+    // Association traversal
+    uint32_t traversal_parent;
+    uint32_t traversal_index;
+    // Object open for reading
+    uint32_t read_handle;
+    uint32_t read_pos;
+    // Object open for writing
+    uint32_t write_handle;
+    uint32_t write_pos;
+    // Unique identifier
+    uint32_t last_handle;
+} fs_operation_t;
+
+static fs_operation_t _fs_operation = {
+    .last_handle = 1
+};
+
+//--------------------------------------------------------------------+
+// INTERNAL FUNCTIONS
+//--------------------------------------------------------------------+
+
+// Get pointer to object info from handle
+fs_object_info_t *fs_object_get_from_handle(uint32_t handle);
+
+// Get the number of allocated nodes in filesystem
+unsigned int fs_get_object_count(void);
+
+fs_object_info_t *fs_object_get_from_handle(uint32_t handle)
+{
+    fs_object_info_t *obj;
+    for (unsigned int i=0; i<FS_MAX_NODES; i++)
+    {
+        obj = &_fs_objects[i];
+        if (obj->allocated && obj->handle == handle)
+            return obj;
+    }
+    return NULL;
+}
+
+unsigned int fs_get_object_count(void)
+{
+    unsigned int s = 0;
+    for (unsigned int i = 0; i<FS_MAX_NODES; i++)
+    {
+        if (_fs_objects[i].allocated)
+            s++;
+    }
+    return s;
+}
+
+//--------------------------------------------------------------------+
+// API
+//--------------------------------------------------------------------+
+mtp_response_t tud_mtp_storage_open_session(uint32_t *session_id)
+{
+    if (*session_id == 0)
+    {
+        TU_LOG1("Invalid session ID\r\n");
+        return MTP_RESC_INVALID_PARAMETER;
+    }
+    if (_fs_operation.session_id != 0)
+    {
+        *session_id = _fs_operation.session_id;
+        TU_LOG1("ERR: Session %ld already open\r\n", _fs_operation.session_id);
+        return MTP_RESC_SESSION_ALREADY_OPEN;
+    }
+    _fs_operation.session_id = *session_id;
+    TU_LOG1("Open session with id %ld\r\n", _fs_operation.session_id);
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_close_session(uint32_t session_id)
+{
+    if (session_id != _fs_operation.session_id)
+    {
+        TU_LOG1("ERR: Session %ld not open\r\n", session_id);
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    _fs_operation.session_id = 0;
+    TU_LOG1("Session closed\r\n");
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_get_storage_id(uint32_t *storage_id)
+{
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    *storage_id = STORAGE_ID(0x0001, 0x0001);
+    TU_LOG1("Retrieved storage identifier %ld\r\n", *storage_id);
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_get_storage_info(uint32_t storage_id, mtp_storage_info_t *info)
+{
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    if (storage_id != STORAGE_ID(0x0001, 0x0001))
+    {
+        TU_LOG1("ERR: Unexpected storage id %ld\r\n", storage_id);
+        return MTP_RESC_INVALID_STORAGE_ID;
+    }
+    info->storage_type = MTP_STORAGE_TYPE_FIXED_RAM;
+    info->filesystem_type = MTP_FILESYSTEM_TYPE_GENERIC_HIERARCHICAL;
+    info->access_capability = MTP_ACCESS_CAPABILITY_READ_WRITE;
+    info->max_capacity_in_bytes = FS_MAX_NODES * FS_MAX_NODE_BYTES;
+    info->free_space_in_objects = FS_MAX_NODES - fs_get_object_count();
+    info->free_space_in_bytes = info->free_space_in_objects * FS_MAX_NODE_BYTES;
+    mtpd_gct_append_wstring(MTPD_STORAGE_DESCRIPTION);
+    mtpd_gct_append_wstring(MTPD_VOLUME_IDENTIFIER);
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_format(uint32_t storage_id)
+{
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    if (storage_id != STORAGE_ID(0x0001, 0x0001))
+    {
+        TU_LOG1("ERR: Unexpected storage id %ld\r\n", storage_id);
+        return MTP_RESC_INVALID_STORAGE_ID;
+    }
+
+    // Simply deallocate all entries
+    for (unsigned int i=0; i<FS_MAX_NODES; i++)
+        _fs_objects[i].allocated = false;
+    TU_LOG1("Format completed\r\n");
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_association_get_object_handle(uint32_t storage_id, uint32_t parent_object_handle, uint32_t *next_child_handle)
+{
+    fs_object_info_t *obj;
+
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    // We just have one storage, same reply if querying all storages
+    if (storage_id != 0xFFFFFFFF && storage_id != STORAGE_ID(0x0001, 0x0001))
+    {
+        TU_LOG1("ERR: Unexpected storage id %ld\r\n", storage_id);
+        return MTP_RESC_INVALID_STORAGE_ID;
+    }
+
+    // Request for objects with no parent (0xFFFFFFFF) are considered root objects
+    // Note: implementation may pass 0 as parent_object_handle
+    if (parent_object_handle == 0xFFFFFFFF)
+        parent_object_handle = 0;
+
+    if (parent_object_handle != _fs_operation.traversal_parent)
+    {
+        _fs_operation.traversal_parent = parent_object_handle;
+        _fs_operation.traversal_index = 0;
+    }
+
+    for (unsigned int i=_fs_operation.traversal_index; i<FS_MAX_NODES; i++)
+    {
+        obj = &_fs_objects[i];
+        if (obj->allocated && obj->parent == parent_object_handle)
+        {
+            _fs_operation.traversal_index = i+1;
+            *next_child_handle = obj->handle;
+            TU_LOG1("Association %ld -> child %ld\r\n", parent_object_handle, obj->handle);
+            return MTP_RESC_OK;
+        }
+    }
+    TU_LOG1("Association traversal completed\r\n");
+    _fs_operation.traversal_index = 0;
+    *next_child_handle = 0;
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_write_info(uint32_t storage_id, uint32_t parent_object, uint32_t *new_object_handle, const mtp_object_info_t *info)
+{
+    fs_object_info_t *obj = NULL;
+
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+    // Accept command on default storage
+    if (storage_id != 0xFFFFFFFF && storage_id != STORAGE_ID(0x0001, 0x0001))
+    {
+        TU_LOG1("ERR: Unexpected storage id %ld\r\n", storage_id);
+        return MTP_RESC_INVALID_STORAGE_ID;
+    }
+
+    if (info->object_compressed_size > FS_MAX_NODE_BYTES)
+    {
+        TU_LOG1("Object size %ld is more than maximum %ld\r\n", info->object_compressed_size, FS_MAX_NODE_BYTES);
+        return MTP_RESC_STORE_FULL;
+    }
+
+    // Request for objects with no parent (0xFFFFFFFF) are considered root objects
+    if (parent_object == 0xFFFFFFFF)
+        parent_object = 0;
+
+    // Ensure we are not creating an orphaned object outside root
+    if (parent_object != 0)
+    {
+        obj = fs_object_get_from_handle(parent_object);
+        if (obj == NULL)
+        {
+            TU_LOG1("Parent %ld does not exist\r\n", parent_object);
+            return MTP_RESC_INVALID_PARENT_OBJECT;
+        }
+        if (!obj->association)
+        {
+            TU_LOG1("Parent %ld is not an association\r\n", parent_object);
+            return MTP_RESC_INVALID_PARENT_OBJECT;
+        }
+    }
+
+    // Search for first free object
+    for (unsigned int i=0; i<FS_MAX_NODES; i++)
+    {
+        if (!_fs_objects[i].allocated)
+        {
+            obj = &_fs_objects[i];
+            break;
+        }
+    }
+
+    if (obj == NULL)
+    {
+        TU_LOG1("No space left on device\r\n");
+        return MTP_RESC_STORE_FULL;
+    }
+
+    // Fill-in structure
+    obj->allocated = true;
+    obj->handle = ++_fs_operation.last_handle;
+    obj->parent = parent_object;
+    obj->size = info->object_compressed_size;
+    obj->association = info->object_format == MTP_OBJF_ASSOCIATION;
+
+    // Extract variable data
+    uint16_t offset_data = sizeof(mtp_object_info_t);
+    mtpd_gct_get_string(&offset_data, obj->name, FS_MAX_NODE_NAME_LEN);
+    mtpd_gct_get_string(&offset_data, obj->created, FS_ISODATETIME_LEN);
+    mtpd_gct_get_string(&offset_data, obj->modified, FS_ISODATETIME_LEN);
+
+    TU_LOG1("Create %s %s with handle %ld, parent %ld and size %ld\r\n",
+        obj->association ? "association" : "object",
+         obj->name, obj->handle, obj->parent, obj->size);
+    *new_object_handle = obj->handle;
+    // Initialize operation
+    _fs_operation.write_handle = obj->handle;
+    _fs_operation.write_pos = 0;
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_read_info(uint32_t object_handle, mtp_object_info_t *info)
+{
+    const fs_object_info_t *obj;
+
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+
+    obj = fs_object_get_from_handle(object_handle);
+    if (obj == NULL)
+    {
+        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+        return MTP_RESC_INVALID_OBJECT_HANDLE;
+    }
+
+    memset(info, 0, sizeof(mtp_object_info_t));
+    info->storage_id = STORAGE_ID(0x0001, 0x0001);
+    if (obj->association)
+    {
+        info->object_format = MTP_OBJF_ASSOCIATION;
+        info->protection_status = MTP_PROTECTION_STATUS_NO_PROTECTION;
+        info->object_compressed_size = 0;
+        info->association_type = MTP_ASSOCIATION_UNDEFINED;
+    }
+    else
+    {
+        info->object_format = MTP_OBJF_UNDEFINED;
+        info->protection_status = MTP_PROTECTION_STATUS_NO_PROTECTION;
+        info->object_compressed_size = obj->size;
+        info->association_type = MTP_ASSOCIATION_UNDEFINED;
+    }
+    info->thumb_format = MTP_OBJF_UNDEFINED;
+    info->parent_object = obj->parent;
+
+    mtpd_gct_append_wstring(obj->name);
+    mtpd_gct_append_wstring(obj->created); // date_created
+    mtpd_gct_append_wstring(obj->modified); // date_modified
+    mtpd_gct_append_wstring(""); // keywords, not used
+
+    TU_LOG1("Retrieve object %s with handle %ld\r\n", obj->name, obj->handle);
+
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_write(uint32_t object_handle, const uint8_t *buffer, uint32_t size)
+{
+    fs_object_info_t *obj;
+
+    obj = fs_object_get_from_handle(object_handle);
+    if (obj == NULL)
+    {
+        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+        return MTP_RESC_INVALID_OBJECT_HANDLE;
+    }
+    // It's a requirement that this command is preceded by a write info
+    if (object_handle != _fs_operation.write_handle)
+    {
+        TU_LOG1("ERR: Object %ld not open for write\r\n", object_handle);
+        return MTP_RESC_NO_VALID_OBJECTINFO;
+    }
+
+    TU_LOG1("Write object %ld: data chunk at %ld/%ld bytes at offset %ld\r\n", object_handle, _fs_operation.write_pos, obj->size, size);
+    TU_ASSERT(obj->size >= _fs_operation.write_pos + size, MTP_RESC_INCOMPLETE_TRANSFER);
+    if (_fs_operation.write_pos + size < FS_MAX_NODE_BYTES)
+        memcpy(&obj->data[_fs_operation.write_pos], buffer, size);
+    _fs_operation.write_pos += size;
+    // Write operation completed
+    if (_fs_operation.write_pos == obj->size)
+    {
+        _fs_operation.write_handle = 0;
+        _fs_operation.write_pos = 0;
+    }
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_size(uint32_t object_handle, uint32_t *size)
+{
+    const fs_object_info_t *obj;
+    obj = fs_object_get_from_handle(object_handle);
+    if (obj == NULL)
+    {
+        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+        return MTP_RESC_INVALID_OBJECT_HANDLE;
+    }
+    *size = obj->size;
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_read(uint32_t object_handle, void *buffer, uint32_t buffer_size, uint32_t *read_count)
+{
+    const fs_object_info_t *obj;
+
+    obj = fs_object_get_from_handle(object_handle);
+
+    if (obj == NULL)
+    {
+        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+        return MTP_RESC_INVALID_OBJECT_HANDLE;
+    }
+    // It's not a requirement that this command is preceded by a read info
+    if (object_handle != _fs_operation.read_handle)
+    {
+        TU_LOG1("ERR: Object %ld not open for read\r\n", object_handle);
+        _fs_operation.read_handle = object_handle;
+        _fs_operation.read_pos = 0;
+    }
+
+    if (obj->size - _fs_operation.read_pos > buffer_size)
+    {
+        TU_LOG1("Read object %ld: %ld bytes at offset %ld\r\n", object_handle, buffer_size, _fs_operation.read_pos);
+        *read_count = buffer_size;
+        if (_fs_operation.read_pos + buffer_size < FS_MAX_NODE_BYTES)
+            memcpy(buffer, &obj->data[_fs_operation.read_pos], *read_count);
+        _fs_operation.read_pos += *read_count;
+    }
+    else
+    {
+        TU_LOG1("Read object %ld: %ld bytes at offset %ld\r\n", object_handle, obj->size - _fs_operation.read_pos, _fs_operation.read_pos);
+        *read_count = obj->size - _fs_operation.read_pos;
+        if (_fs_operation.read_pos + buffer_size < FS_MAX_NODE_BYTES)
+            memcpy(buffer, &obj->data[_fs_operation.read_pos], *read_count);
+        // Read operation completed
+        _fs_operation.read_handle = 0;
+        _fs_operation.read_pos = 0;
+    }
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_move(uint32_t object_handle, uint32_t new_parent_object_handle)
+{
+    fs_object_info_t *obj;
+
+    if (new_parent_object_handle == 0xFFFFFFFF)
+        new_parent_object_handle = 0;
+
+    // Ensure we are not moving to an nonexisting parent
+    if (new_parent_object_handle != 0)
+    {
+        obj = fs_object_get_from_handle(new_parent_object_handle);
+        if (obj == NULL)
+        {
+            TU_LOG1("Parent %ld does not exist\r\n", new_parent_object_handle);
+            return MTP_RESC_INVALID_PARENT_OBJECT;
+        }
+        if (!obj->association)
+        {
+            TU_LOG1("Parent %ld is not an association\r\n", new_parent_object_handle);
+            return MTP_RESC_INVALID_PARENT_OBJECT;
+        }
+    }
+
+    obj = fs_object_get_from_handle(object_handle);
+
+    if (obj == NULL)
+    {
+        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+        return MTP_RESC_INVALID_OBJECT_HANDLE;
+    }
+    TU_LOG1("Move object %ld to new parent %ld\r\n", object_handle, new_parent_object_handle);
+    obj->parent = new_parent_object_handle;
+    return MTP_RESC_OK;
+}
+
+mtp_response_t tud_mtp_storage_object_delete(uint32_t object_handle)
+{
+    fs_object_info_t *obj;
+
+    if (_fs_operation.session_id == 0)
+    {
+        TU_LOG1("ERR: Session not open\r\n");
+        return MTP_RESC_SESSION_NOT_OPEN;
+    }
+
+    if (object_handle == 0xFFFFFFFF)
+        object_handle = 0;
+
+    if (object_handle != 0)
+    {
+        obj = fs_object_get_from_handle(object_handle);
+
+        if (obj == NULL)
+        {
+            TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
+            return MTP_RESC_INVALID_OBJECT_HANDLE;
+        }
+        obj->allocated = false;
+        TU_LOG1("Delete object with handle %ld\r\n", object_handle);
+    }
+
+    if (object_handle == 0 || obj->association)
+    {
+        // Delete also children
+        for (unsigned int i=0; i<FS_MAX_NODES; i++)
+        {
+            obj = &_fs_objects[i];
+            if (obj->allocated && obj->parent == object_handle)
+            {
+                tud_mtp_storage_object_delete(obj->handle);
+            }
+        }
+    }
+
+    return MTP_RESC_OK;
+}
+
+void tud_mtp_storage_object_done(void)
+{
+}
+
+void tud_mtp_storage_cancel(void)
+{
+    fs_object_info_t *obj;
+
+    _fs_operation.traversal_parent = 0;
+    _fs_operation.traversal_index = 0;
+    _fs_operation.read_handle = 0;
+    _fs_operation.read_pos = 0;
+    // If write operation is canceled, discard object
+    if (_fs_operation.write_handle)
+    {
+        obj = fs_object_get_from_handle(_fs_operation.write_handle);
+        if (obj)
+            obj->allocated = false;
+    }
+    _fs_operation.write_handle = 0;
+    _fs_operation.write_pos = 0;
+}
+
+void tud_mtp_storage_reset(void)
+{
+    tud_mtp_storage_cancel();
+    _fs_operation.session_id = 0;
+}
diff --git a/examples/device/mtp/src/tusb_config.h b/examples/device/mtp/src/tusb_config.h
new file mode 100644
index 000000000..251a99fd3
--- /dev/null
+++ b/examples/device/mtp/src/tusb_config.h
@@ -0,0 +1,112 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#ifndef _TUSB_CONFIG_H_
+#define _TUSB_CONFIG_H_
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+//--------------------------------------------------------------------+
+// Board Specific Configuration
+//--------------------------------------------------------------------+
+
+// RHPort number used for device can be defined by board.mk, default to port 0
+#ifndef BOARD_TUD_RHPORT
+#define BOARD_TUD_RHPORT      0
+#endif
+
+// RHPort max operational speed can defined by board.mk
+#ifndef BOARD_TUD_MAX_SPEED
+#define BOARD_TUD_MAX_SPEED   OPT_MODE_DEFAULT_SPEED
+#endif
+
+//--------------------------------------------------------------------
+// COMMON CONFIGURATION
+//--------------------------------------------------------------------
+
+// defined by compiler flags for flexibility
+#ifndef CFG_TUSB_MCU
+#error CFG_TUSB_MCU must be defined
+#endif
+
+#ifndef CFG_TUSB_OS
+#define CFG_TUSB_OS           OPT_OS_NONE
+#endif
+
+#ifndef CFG_TUSB_DEBUG
+#define CFG_TUSB_DEBUG        0
+#endif
+
+// Enable Device stack
+#define CFG_TUD_ENABLED       1
+
+// Default is max speed that hardware controller could support with on-chip PHY
+#define CFG_TUD_MAX_SPEED     BOARD_TUD_MAX_SPEED
+
+/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
+ * Tinyusb use follows macros to declare transferring memory so that they can be put
+ * into those specific section.
+ * e.g
+ * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") ))
+ * - CFG_TUSB_MEM_ALIGN   : __attribute__ ((aligned(4)))
+ */
+#ifndef CFG_TUSB_MEM_SECTION
+#define CFG_TUSB_MEM_SECTION
+#endif
+
+#ifndef CFG_TUSB_MEM_ALIGN
+#define CFG_TUSB_MEM_ALIGN        __attribute__ ((aligned(4)))
+#endif
+
+//--------------------------------------------------------------------
+// DEVICE CONFIGURATION
+//--------------------------------------------------------------------
+
+#ifndef CFG_TUD_ENDPOINT0_SIZE
+#define CFG_TUD_ENDPOINT0_SIZE    64
+#endif
+
+//------------- CLASS -------------//
+#define CFG_TUD_MTP               1
+
+#define CFG_TUD_MANUFACTURER "TinyUsb Manufacturer"
+#define CFG_TUD_MODEL "TinyUsb Device"
+
+#define CFG_MTP_EP_SIZE 64
+#define CFG_MTP_EVT_EP_SIZE 64
+#define CFG_MTP_EVT_INTERVAL 100
+
+#define CFG_MTP_DEVICE_VERSION "1.0"
+#define CFG_MTP_SERIAL_NUMBER "0"
+#define CFG_MTP_INTERFACE (CFG_TUD_MODEL " MTP")
+#define CFG_MTP_STORAGE_ID_COUNT 1
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* _TUSB_CONFIG_H_ */
diff --git a/examples/device/mtp/src/usb_descriptors.c b/examples/device/mtp/src/usb_descriptors.c
new file mode 100644
index 000000000..73685c3fd
--- /dev/null
+++ b/examples/device/mtp/src/usb_descriptors.c
@@ -0,0 +1,193 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "bsp/board_api.h"
+#include "tusb.h"
+
+/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug.
+ * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC.
+ *
+ * Auto ProductID layout's Bitmap:
+ *   [MSB]  MTP | VENDOR | MIDI | HID | MSC | CDC [LSB]
+ */
+#define _PID_MAP(itf, n)  ( (CFG_TUD_##itf) << (n) )
+#define USB_PID           (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \
+                           _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) | _PID_MAP(MTP, 5))
+
+#define USB_VID   0xCafe
+#define USB_BCD   0x0200
+
+//--------------------------------------------------------------------+
+// Device Descriptors
+//--------------------------------------------------------------------+
+tusb_desc_device_t const desc_device =
+{
+    .bLength            = sizeof(tusb_desc_device_t),
+    .bDescriptorType    = TUSB_DESC_DEVICE,
+    .bcdUSB             = USB_BCD,
+    .bDeviceClass       = TUSB_CLASS_UNSPECIFIED,
+    .bDeviceSubClass    = 0x00,
+    .bDeviceProtocol    = 0x00,
+    .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,
+
+    .idVendor           = USB_VID,
+    .idProduct          = USB_PID,
+    .bcdDevice          = 0x0100,
+
+    .iManufacturer      = 0x01,
+    .iProduct           = 0x02,
+    .iSerialNumber      = 0x03,
+
+    .bNumConfigurations = 0x01
+};
+
+// Invoked when received GET DEVICE DESCRIPTOR
+// Application return pointer to descriptor
+uint8_t const *tud_descriptor_device_cb(void)
+{
+  return (uint8_t const *) &desc_device;
+}
+
+//--------------------------------------------------------------------+
+// Configuration Descriptor
+//--------------------------------------------------------------------+
+
+enum
+{
+  ITF_NUM_MTP = 0,
+  ITF_NUM_TOTAL
+};
+
+#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX
+  // LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number
+  // 0 control, 1 In, 2 Bulk, 3 Iso, 4 In, 5 Bulk etc ...
+  #define EPNUM_MTP_EVT     0x81
+  #define EPNUM_MTP_OUT     0x02
+  #define EPNUM_MTP_IN      0x82
+
+#elif CFG_TUSB_MCU == OPT_MCU_CXD56
+  // CXD56 USB driver has fixed endpoint type (bulk/interrupt/iso) and direction (IN/OUT) by its number
+  // 0 control (IN/OUT), 1 Bulk (IN), 2 Bulk (OUT), 3 In (IN), 4 Bulk (IN), 5 Bulk (OUT), 6 In (IN)
+  #define EPNUM_MTP_EVT     0x83
+  #define EPNUM_MTP_OUT     0x02
+  #define EPNUM_MTP_IN      0x81
+
+#elif defined(TUD_ENDPOINT_ONE_DIRECTION_ONLY)
+  // MCUs that don't support a same endpoint number with different direction IN and OUT defined in tusb_mcu.h
+  //    e.g EP1 OUT & EP1 IN cannot exist together
+  #define EPNUM_MTP_EVT     0x81
+  #define EPNUM_MTP_OUT     0x03
+  #define EPNUM_MTP_IN      0x82
+
+#else
+  #define EPNUM_MTP_EVT     0x81
+  #define EPNUM_MTP_OUT     0x02
+  #define EPNUM_MTP_IN      0x82
+#endif
+
+#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_MTP_DESC_LEN)
+
+uint8_t const desc_fs_configuration[] =
+{
+  // Config number, interface count, string index, total length, attribute, power in mA
+    TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, 0x00, 100),
+    TUD_MTP_DESCRIPTOR(ITF_NUM_MTP, 4, EPNUM_MTP_EVT, CFG_MTP_EVT_EP_SIZE, CFG_MTP_EVT_INTERVAL, EPNUM_MTP_OUT, EPNUM_MTP_IN, CFG_MTP_EP_SIZE),
+};
+
+// Invoked when received GET CONFIGURATION DESCRIPTOR
+// Application return pointer to descriptor
+// Descriptor contents must exist long enough for transfer to complete
+uint8_t const *tud_descriptor_configuration_cb(uint8_t index)
+{
+  (void) index; // for multiple configurations
+  return desc_fs_configuration;
+}
+
+//--------------------------------------------------------------------+
+// String Descriptors
+//--------------------------------------------------------------------+
+
+// String Descriptor Index
+enum {
+  STRID_LANGID = 0,
+  STRID_MANUFACTURER,
+  STRID_PRODUCT,
+  STRID_SERIAL,
+  STRID_MTP,
+};
+
+// array of pointer to string descriptors
+char const *string_desc_arr[] =
+{
+  (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
+  CFG_TUD_MANUFACTURER,          // 1: Manufacturer
+  CFG_TUD_MODEL,                 // 2: Product
+  NULL,                          // 3: Serials will use unique ID if possible
+  CFG_MTP_INTERFACE,             // 4: MTP Interface
+};
+
+static uint16_t _desc_str[32 + 1];
+
+// Invoked when received GET STRING DESCRIPTOR request
+// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
+uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
+  (void) langid;
+  size_t chr_count;
+
+  switch ( index ) {
+    case STRID_LANGID:
+      memcpy(&_desc_str[1], string_desc_arr[0], 2);
+      chr_count = 1;
+      break;
+
+    case STRID_SERIAL:
+      chr_count = board_usb_get_serial(_desc_str + 1, 32);
+      break;
+
+    default:
+      // Note: the 0xEE index string is a Microsoft OS 1.0 Descriptors.
+      // https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/microsoft-defined-usb-descriptors
+
+      if ( !(index < sizeof(string_desc_arr) / sizeof(string_desc_arr[0])) ) return NULL;
+
+      const char *str = string_desc_arr[index];
+
+      // Cap at max char
+      chr_count = strlen(str);
+      size_t const max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1; // -1 for string type
+      if ( chr_count > max_count ) chr_count = max_count;
+
+      // Convert ASCII string into UTF-16
+      for ( size_t i = 0; i < chr_count; i++ ) {
+        _desc_str[1 + i] = str[i];
+      }
+      break;
+  }
+
+  // first byte is length (including header), second byte is string type
+  _desc_str[0] = (uint16_t) ((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));
+
+  return _desc_str;
+}