implement get object, close session

Author: hathach

examples/device/mtp/src/mtp_fs_example.c

@@ -105,6 +105,7 @@ enum {
   SUPPORTED_STORAGE_ID = 0x00010001u // physical = 1, logical = 1
 };
 
+static bool is_session_opened = false;
 
 //--------------------------------------------------------------------+
 // OPERATING STATUS
@@ -160,14 +161,9 @@ unsigned int fs_get_object_count(void) {
 
 int32_t tud_mtp_data_complete_cb(uint8_t idx, mtp_container_header_t* cmd_header, mtp_generic_container_t* resp_block, tusb_xfer_result_t xfer_result, uint32_t xferred_bytes) {
   (void) idx;
-  // switch (cmd_header->code) {
-  //   default: break;
-  // }
   resp_block->len = MTP_CONTAINER_HEADER_LENGTH;
   resp_block->code = (xfer_result == XFER_RESULT_SUCCESS) ? MTP_RESP_OK : MTP_RESP_GENERAL_ERROR;
-
   tud_mtp_response_send(resp_block);
-
   return 0;
 }
 
@@ -195,7 +191,24 @@ int32_t tud_mtp_command_received_cb(uint8_t idx, mtp_generic_container_t* cmd_bl
     }
 
     case MTP_OP_OPEN_SESSION:
-      out_block->code = MTP_RESP_OK;
+      if (is_session_opened) {
+        //return MTP_RESP_SESSION_ALREADY_OPEN;
+        out_block->code = MTP_RESP_SESSION_ALREADY_OPEN;
+      }else {
+        out_block->code = MTP_RESP_OK;
+      }
+      is_session_opened = true;
+      tud_mtp_response_send(out_block);
+      break;
+
+    case MTP_OP_CLOSE_SESSION:
+      if (!is_session_opened) {
+        // return MTP_RESP_SESSION_NOT_OPEN;
+        out_block->code = MTP_RESP_SESSION_NOT_OPEN;
+      } else {
+        out_block->code = MTP_RESP_OK;
+      }
+      is_session_opened = false;
       tud_mtp_response_send(out_block);
       break;
 
@@ -272,13 +285,12 @@ int32_t tud_mtp_command_received_cb(uint8_t idx, mtp_generic_container_t* cmd_bl
     }
 
     case MTP_OP_GET_OBJECT_INFO: {
-      const uint32_t object_handle = cmd_block->data[0];
-      fs_object_info_t* obj = fs_object_get_from_handle(object_handle);
+      const uint32_t obj_handle = cmd_block->data[0];
+      fs_object_info_t* obj = fs_object_get_from_handle(obj_handle);
       if (obj == NULL) {
-        TU_LOG1("ERR: Object with handle %ld does not exist\r\n", object_handle);
         return MTP_RESP_INVALID_OBJECT_HANDLE;
       }
-      mtp_object_info_header_t object_info_header = {
+      mtp_object_info_header_t obj_info_header = {
         .storage_id = SUPPORTED_STORAGE_ID,
         .object_format = MTP_OBJ_FORMAT_TEXT,
         .protection_status =  MTP_PROTECTION_STATUS_NO_PROTECTION,
@@ -295,7 +307,7 @@ int32_t tud_mtp_command_received_cb(uint8_t idx, mtp_generic_container_t* cmd_bl
         .association_desc = 0,
         .sequence_number = 0
       };
-      mtp_container_add_raw(out_block, &object_info_header, sizeof(object_info_header));
+      mtp_container_add_raw(out_block, &obj_info_header, sizeof(obj_info_header));
       mtp_container_add_cstring(out_block, obj->name);
       mtp_container_add_cstring(out_block, obj->created);
       mtp_container_add_cstring(out_block, obj->modified);
@@ -305,6 +317,18 @@ int32_t tud_mtp_command_received_cb(uint8_t idx, mtp_generic_container_t* cmd_bl
       break;
     }
 
+    case MTP_OP_GET_OBJECT: {
+      const uint32_t obj_handle = cmd_block->data[0];
+      fs_object_info_t* obj = fs_object_get_from_handle(obj_handle);
+      if (obj == NULL) {
+        return MTP_RESP_INVALID_OBJECT_HANDLE;
+      }
+
+      mtp_container_add_raw(out_block, obj->data, obj->size);
+      tud_mtp_data_send(out_block);
+      break;
+    }
+
     default: return MTP_RESP_OPERATION_NOT_SUPPORTED;
   }
 

src/class/mtp/mtp_device.c

@@ -79,14 +79,10 @@ typedef struct {
 //--------------------------------------------------------------------+
 // Checker
 static mtp_phase_type_t mtpd_chk_generic(const char *func_name, const bool err_cd, const uint16_t ret_code, const char *message);
-static mtp_phase_type_t mtpd_chk_session_open(const char *func_name);
 
 // MTP commands
 static mtp_phase_type_t mtpd_handle_cmd(mtpd_interface_t* p_mtp);
 static mtp_phase_type_t mtpd_handle_data(void);
-static mtp_phase_type_t mtpd_handle_cmd_close_session(void);
-static mtp_phase_type_t mtpd_handle_cmd_get_object(void);
-static mtp_phase_type_t mtpd_handle_dti_get_object(void);
 static mtp_phase_type_t mtpd_handle_cmd_delete_object(void);
 static mtp_phase_type_t mtpd_handle_cmd_send_object_info(void);
 static mtp_phase_type_t mtpd_handle_dto_send_object_info(void);
@@ -272,6 +268,7 @@ bool mtpd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
       break;
     }
 
+#if 0
     case MTP_PHASE_DATA_IN:
       p_mtp->xferred_len += xferred_bytes;
       p_mtp->handled_len = p_mtp->xferred_len;
@@ -333,16 +330,17 @@ bool mtpd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
         } else if (p_mtp->handled_len == 0) {
           // First data block includes container header + container data
           TU_ASSERT(usbd_edpt_xfer(rhport, p_mtp->ep_out,
-                             (uint8_t*) p_container + p_mtp->xferred_len,
+                                   (uint8_t*) p_container + p_mtp->xferred_len,
                                    (uint16_t)TU_MIN(p_mtp->total_len - p_mtp->xferred_len, CFG_MTP_EP_SIZE)));
         } else {
           // Successive data block includes only container data
           TU_ASSERT(usbd_edpt_xfer(rhport, p_mtp->ep_out,
-                            ((uint8_t *)(&p_container->data)) + p_mtp->xferred_len - p_mtp->handled_len,
-                                  (uint16_t)TU_MIN(p_mtp->total_len - p_mtp->xferred_len, CFG_MTP_EP_SIZE)));
+                                   ((uint8_t *)(&p_container->data)) + p_mtp->xferred_len - p_mtp->handled_len,
+                                   (uint16_t)TU_MIN(p_mtp->total_len - p_mtp->xferred_len, CFG_MTP_EP_SIZE)));
         }
       }
       break;
+#endif
 
     case MTP_PHASE_RESPONSE_QUEUED:
       // response phase is complete -> prepare for new command
@@ -391,12 +389,16 @@ mtp_phase_type_t mtpd_handle_cmd(mtpd_interface_t* p_mtp) {
       TU_LOG_DRV("  MTP command: MTP_OP_GET_DEVICE_INFO\n");
       tud_mtp_device_info_t dev_info = {
         .standard_version = 100,
-        .mtp_vendor_extension_id = 0xFFFFFFFFU,
+        .mtp_vendor_extension_id = 6, // MTP specs say 0xFFFFFFFF but libMTP check for value 6
         .mtp_version = 100,
+#ifdef CFG_TUD_MTP_DEVICEINFO_EXTENSIONS
         .mtp_extensions = {
           .count = sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS),
           .utf16 = { 0 }
         },
+#else
+        .mtp_extensions = 0,
+#endif
         .functional_mode = 0x0000,
         .supported_operations = {
           .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
@@ -419,9 +421,11 @@ mtp_phase_type_t mtpd_handle_cmd(mtpd_interface_t* p_mtp) {
           .arr = { CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS }
         }
       };
+#ifdef CFG_TUD_MTP_DEVICEINFO_EXTENSIONS
       for (uint8_t i=0; i < dev_info.mtp_extensions.count; i++) {
         dev_info.mtp_extensions.utf16[i] = (uint16_t)CFG_TUD_MTP_DEVICEINFO_EXTENSIONS[i];
       }
+#endif
       p_container->len = MTP_CONTAINER_HEADER_LENGTH + sizeof(tud_mtp_device_info_t);
       p_container->type = MTP_CONTAINER_TYPE_DATA_BLOCK;
       p_container->code = MTP_OP_GET_DEVICE_INFO;
@@ -437,7 +441,7 @@ mtp_phase_type_t mtpd_handle_cmd(mtpd_interface_t* p_mtp) {
 
     case MTP_OP_CLOSE_SESSION:
       TU_LOG_DRV("  MTP command: MTP_OP_CLOSE_SESSION\n");
-      return mtpd_handle_cmd_close_session();
+      break;
 
     case MTP_OP_GET_STORAGE_IDS:
       TU_LOG_DRV("  MTP command: MTP_OP_GET_STORAGE_IDS\n");
@@ -457,7 +461,8 @@ mtp_phase_type_t mtpd_handle_cmd(mtpd_interface_t* p_mtp) {
 
     case MTP_OP_GET_OBJECT:
       TU_LOG_DRV("  MTP command: MTP_OP_GET_OBJECT\n");
-      return mtpd_handle_cmd_get_object();
+      break;
+
     case MTP_OP_DELETE_OBJECT:
       TU_LOG_DRV("  MTP command: MTP_OP_DELETE_OBJECT\n");
       return mtpd_handle_cmd_delete_object();
@@ -495,9 +500,6 @@ mtp_phase_type_t mtpd_handle_data(void)
 
   switch(p_container->code)
   {
-    case MTP_OP_GET_OBJECT:
-      TU_LOG_DRV("  MTP command: MTP_OP_GET_OBJECT-DATA_IN\n");
-      return mtpd_handle_dti_get_object();
     case MTP_OP_SEND_OBJECT_INFO:
       TU_LOG_DRV("  MTP command: MTP_OP_SEND_OBJECT_INFO-DATA_OUT\n");
       return mtpd_handle_dto_send_object_info();
@@ -511,79 +513,6 @@ mtp_phase_type_t mtpd_handle_data(void)
   return true;
 }
 
-
-mtp_phase_type_t mtpd_handle_cmd_close_session(void)
-{
-  mtp_generic_container_t* p_container = &_mtpd_epbuf.container;
-  uint32_t session_id = p_container->data[0];
-
-  mtp_response_t res = tud_mtp_storage_close_session(session_id);
-
-  _mtpd_itf.session_id = session_id;
-
-  p_container->len = MTP_CONTAINER_HEADER_LENGTH;
-  p_container->type = MTP_CONTAINER_TYPE_RESPONSE_BLOCK;
-  p_container->code = res;
-
-  return MTP_PHASE_RESPONSE;
-}
-
-mtp_phase_type_t mtpd_handle_cmd_get_object(void)
-{
-  mtp_generic_container_t* p_container = &_mtpd_epbuf.container;
-  _mtpd_get_object_handle = p_container->data[0];
-
-  // Continue with DATA-IN
-  return mtpd_handle_dti_get_object();
-}
-
-mtp_phase_type_t mtpd_handle_dti_get_object(void)
-{
-  mtp_response_t res;
-  mtp_phase_type_t phase;
-  uint32_t file_size = 0;
-  mtp_generic_container_t* p_container = &_mtpd_epbuf.container;
-  res = tud_mtp_storage_object_size(_mtpd_get_object_handle, &file_size);
-  if ((phase = mtpd_chk_generic(__func__, (res != MTP_RESP_OK), res, "")) != MTP_PHASE_NONE) {
-    return phase;
-  }
-  p_container->len = MTP_CONTAINER_HEADER_LENGTH + file_size;
-  p_container->type = MTP_CONTAINER_TYPE_DATA_BLOCK;
-  p_container->code = MTP_OP_GET_OBJECT;
-
-  uint32_t buffer_size;
-  uint32_t read_count;
-  // Data block must be multiple of EP size
-  if (_mtpd_itf.handled_len == 0)
-  {
-    // First data block: include container header
-    buffer_size = ((MTP_MAX_PACKET_SIZE + MTP_CONTAINER_HEADER_LENGTH) / CFG_MTP_EP_SIZE) * CFG_MTP_EP_SIZE - MTP_CONTAINER_HEADER_LENGTH;
-    res = tud_mtp_storage_object_read(_mtpd_get_object_handle, (void *)&p_container->data, buffer_size, &read_count);
-    if ((phase = mtpd_chk_generic(__func__, (res != MTP_RESP_OK), res, "")) != MTP_PHASE_NONE) {
-      return phase;
-    }
-    _mtpd_itf.queued_len = MTP_CONTAINER_HEADER_LENGTH + read_count;
-  }
-  else
-  {
-    // Successive data block: consider only container data
-    buffer_size = (MTP_MAX_PACKET_SIZE / CFG_MTP_EP_SIZE) * CFG_MTP_EP_SIZE;
-    res = tud_mtp_storage_object_read(_mtpd_get_object_handle, (void *)&p_container->data, buffer_size, &read_count);
-    if ((phase = mtpd_chk_generic(__func__, (res != MTP_RESP_OK), res, "")) != MTP_PHASE_NONE) {
-      return phase;
-    }
-    _mtpd_itf.queued_len = read_count;
-  }
-
-  // File completed
-  if (read_count < buffer_size)
-  {
-    tud_mtp_storage_object_done();
-  }
-
-  return MTP_PHASE_DATA_IN;
-}
-
 mtp_phase_type_t mtpd_handle_cmd_delete_object(void)
 {
   mtp_generic_container_t* p_container = &_mtpd_epbuf.container;
@@ -689,21 +618,6 @@ mtp_phase_type_t mtpd_handle_cmd_format_store(void)
 //--------------------------------------------------------------------+
 // Checker
 //--------------------------------------------------------------------+
-mtp_phase_type_t mtpd_chk_session_open(const char *func_name)
-{
-  (void)func_name;
-  mtp_generic_container_t* p_container = &_mtpd_epbuf.container;
-  if (_mtpd_itf.session_id == 0)
-  {
-    TU_LOG_DRV("  MTP error: %s session not open\n", func_name);
-    p_container->type = MTP_CONTAINER_TYPE_RESPONSE_BLOCK;
-    p_container->code = MTP_RESP_SESSION_NOT_OPEN;
-    p_container->len = MTP_CONTAINER_HEADER_LENGTH;
-    return MTP_PHASE_RESPONSE;
-  }
-  return MTP_PHASE_NONE;
-}
-
 mtp_phase_type_t mtpd_chk_generic(const char *func_name, const bool err_cd, const uint16_t ret_code, const char *message)
 {
   (void)func_name;

src/class/mtp/mtp_device.h

@@ -44,7 +44,7 @@ typedef struct {
 
 // Number of supported operations, events, device properties, capture formats, playback formats
 // and max number of characters for strings manufacturer, model, device_version, serial_number
-#define MTP_DEVICE_INFO_TYPEDEF(_extension_nchars, _op_count, _event_count, _devprop_count, _capture_count, _playback_count) \
+#define MTP_DEVICE_INFO_STRUCT(_extension_nchars, _op_count, _event_count, _devprop_count, _capture_count, _playback_count) \
   struct TU_ATTR_PACKED { \
     uint16_t standard_version; \
     uint32_t mtp_vendor_extension_id; \
@@ -59,11 +59,34 @@ typedef struct {
     /* string fields will be added using append function */ \
   }
 
-typedef MTP_DEVICE_INFO_TYPEDEF(
-    sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
+#define MTP_DEVICE_INFO_NO_EXTENSION_STRUCT(_op_count, _event_count, _devprop_count, _capture_count, _playback_count) \
+  struct TU_ATTR_PACKED { \
+    uint16_t standard_version; \
+    uint32_t mtp_vendor_extension_id; \
+    uint16_t mtp_version; \
+    uint8_t mtp_extensions; \
+    uint16_t functional_mode; \
+    mtp_auint16_t(_op_count) supported_operations; \
+    mtp_auint16_t(_event_count) supported_events; \
+    mtp_auint16_t(_devprop_count) supported_device_properties; \
+    mtp_auint16_t(_capture_count) capture_formats; \
+    mtp_auint16_t(_playback_count) playback_formats; \
+    /* string fields will be added using append function */ \
+  }
+
+#ifdef CFG_TUD_MTP_DEVICEINFO_EXTENSIONS
+   typedef MTP_DEVICE_INFO_STRUCT(
+     sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
+     TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES),
+     TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS)
+   ) tud_mtp_device_info_t;
+#else
+  typedef MTP_DEVICE_INFO_NO_EXTENSION_STRUCT(
+    TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
     TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES),
     TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS)
   ) tud_mtp_device_info_t;
+#endif
 
 //--------------------------------------------------------------------+
 // Application API
@@ -76,7 +99,8 @@ bool tud_mtp_response_send(mtp_generic_container_t* resp_block);
 // Application Callbacks
 //--------------------------------------------------------------------+
 
-// Invoked when new command is received
+// Invoked when new command is received. Application fill the out_block with either DATA or RESPONSE container
+// return MTP response code
 int32_t tud_mtp_command_received_cb(uint8_t idx, mtp_generic_container_t* cmd_block, mtp_generic_container_t* out_block);
 
 // Invoked when data phase is complete