Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 69b74506 authored by Jerry Zhang's avatar Jerry Zhang
Browse files

Move mtp descriptors into separate source, add tests 

Functionfs descriptors are moved into MtpDescriptors.cpp.
Added assertions and tests to ensure that descriptors aren't
unintentionally changed, and bug numbers in comments for
future context.

Test: updated MtpFfsHandle_test passes
Bug: 67367056
Change-Id: I90eb5e48a687f366b8919621718e976e83b5b064
parent 5617fb28

media/mtp/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ cc_library_shared { 
    srcs: [

        "MtpDataPacket.cpp",

        "MtpDebug.cpp",

        "MtpDescriptors.cpp",

        "MtpDevHandle.cpp",

        "MtpDevice.cpp",

        "MtpDeviceInfo.cpp",

media/mtp/MtpDescriptors.cpp

0 → 100644
+260 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "MtpDescriptors.h"



namespace android {



const struct usb_interface_descriptor mtp_interface_desc = {

    .bLength = USB_DT_INTERFACE_SIZE,

    .bDescriptorType = USB_DT_INTERFACE,

    .bInterfaceNumber = 0,

    .bNumEndpoints = 3,

    .bInterfaceClass = USB_CLASS_STILL_IMAGE,

    .bInterfaceSubClass = 1,

    .bInterfaceProtocol = 1,

    .iInterface = 1,

};



const struct usb_interface_descriptor ptp_interface_desc = {

    .bLength = USB_DT_INTERFACE_SIZE,

    .bDescriptorType = USB_DT_INTERFACE,

    .bInterfaceNumber = 0,

    .bNumEndpoints = 3,

    .bInterfaceClass = USB_CLASS_STILL_IMAGE,

    .bInterfaceSubClass = 1,

    .bInterfaceProtocol = 1,

};



const struct usb_endpoint_descriptor_no_audio fs_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_FS,

};



const struct usb_endpoint_descriptor_no_audio fs_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_FS,

};



const struct usb_endpoint_descriptor_no_audio intr = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 3 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_INT,

    .wMaxPacketSize = MAX_PACKET_SIZE_EV,

    .bInterval = 6,

};



const struct usb_endpoint_descriptor_no_audio hs_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_HS,

};



const struct usb_endpoint_descriptor_no_audio hs_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_HS,

};



const struct usb_endpoint_descriptor_no_audio ss_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_SS,

};



const struct usb_endpoint_descriptor_no_audio ss_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_SS,

};



const struct usb_ss_ep_comp_descriptor ss_sink_comp = {

    .bLength = sizeof(ss_sink_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

    .bMaxBurst = 6,

};



const struct usb_ss_ep_comp_descriptor ss_source_comp = {

    .bLength = sizeof(ss_source_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

    .bMaxBurst = 6,

};



const struct usb_ss_ep_comp_descriptor ss_intr_comp = {

    .bLength = sizeof(ss_intr_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

};



const struct func_desc mtp_fs_descriptors = {

    .intf = mtp_interface_desc,

    .sink = fs_sink,

    .source = fs_source,

    .intr = intr,

};



const struct func_desc mtp_hs_descriptors = {

    .intf = mtp_interface_desc,

    .sink = hs_sink,

    .source = hs_source,

    .intr = intr,

};



const struct ss_func_desc mtp_ss_descriptors = {

    .intf = mtp_interface_desc,

    .sink = ss_sink,

    .sink_comp = ss_sink_comp,

    .source = ss_source,

    .source_comp = ss_source_comp,

    .intr = intr,

    .intr_comp = ss_intr_comp,

};



const struct func_desc ptp_fs_descriptors = {

    .intf = ptp_interface_desc,

    .sink = fs_sink,

    .source = fs_source,

    .intr = intr,

};



const struct func_desc ptp_hs_descriptors = {

    .intf = ptp_interface_desc,

    .sink = hs_sink,

    .source = hs_source,

    .intr = intr,

};



const struct ss_func_desc ptp_ss_descriptors = {

    .intf = ptp_interface_desc,

    .sink = ss_sink,

    .sink_comp = ss_sink_comp,

    .source = ss_source,

    .source_comp = ss_source_comp,

    .intr = intr,

    .intr_comp = ss_intr_comp,

};



const struct functionfs_strings mtp_strings = {

    .header = {

        .magic = htole32(FUNCTIONFS_STRINGS_MAGIC),

        .length = htole32(sizeof(mtp_strings)),

        .str_count = htole32(1),

        .lang_count = htole32(1),

    },

    .lang0 = {

        .code = htole16(0x0409),

        .str1 = STR_INTERFACE,

    },

};



const struct usb_os_desc_header mtp_os_desc_header = {

    .interface = htole32(1),

    .dwLength = htole32(sizeof(usb_os_desc_header) + sizeof(usb_ext_compat_desc)),

    .bcdVersion = htole16(1),

    .wIndex = htole16(4),

    .bCount = htole16(1),

    .Reserved = htole16(0),

};



const struct usb_ext_compat_desc mtp_os_desc_compat = {

    .bFirstInterfaceNumber = 0,

    .Reserved1 = htole32(1),

    .CompatibleID = { 'M', 'T', 'P' },

    .SubCompatibleID = {0},

    .Reserved2 = {0},

};



const struct usb_ext_compat_desc ptp_os_desc_compat = {

    .bFirstInterfaceNumber = 0,

    .Reserved1 = htole32(1),

    .CompatibleID = { 'P', 'T', 'P' },

    .SubCompatibleID = {0},

    .Reserved2 = {0},

};



const struct desc_v2 mtp_desc_v2 = {

    .header = {

        .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),

        .length = htole32(sizeof(struct desc_v2)),

        .flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC |

                 FUNCTIONFS_HAS_SS_DESC | FUNCTIONFS_HAS_MS_OS_DESC,

    },

    .fs_count = 4,

    .hs_count = 4,

    .ss_count = 7,

    .os_count = 1,

    .fs_descs = mtp_fs_descriptors,

    .hs_descs = mtp_hs_descriptors,

    .ss_descs = mtp_ss_descriptors,

    .os_header = mtp_os_desc_header,

    .os_desc = mtp_os_desc_compat,

};



const struct desc_v2 ptp_desc_v2 = {

    .header = {

        .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),

        .length = htole32(sizeof(struct desc_v2)),

        .flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC |

                 FUNCTIONFS_HAS_SS_DESC | FUNCTIONFS_HAS_MS_OS_DESC,

    },

    .fs_count = 4,

    .hs_count = 4,

    .ss_count = 7,

    .os_count = 1,

    .fs_descs = ptp_fs_descriptors,

    .hs_descs = ptp_hs_descriptors,

    .ss_descs = ptp_ss_descriptors,

    .os_header = mtp_os_desc_header,

    .os_desc = ptp_os_desc_compat,

};



const struct desc_v1 mtp_desc_v1 = {

    .header = {

        .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),

        .length = htole32(sizeof(struct desc_v1)),

        .fs_count = 4,

        .hs_count = 4,

    },

    .fs_descs = mtp_fs_descriptors,

    .hs_descs = mtp_hs_descriptors,

};



const struct desc_v1 ptp_desc_v1 = {

    .header = {

        .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),

        .length = htole32(sizeof(struct desc_v1)),

        .fs_count = 4,

        .hs_count = 4,

    },

    .fs_descs = ptp_fs_descriptors,

    .hs_descs = ptp_hs_descriptors,

};



}; // namespace android

media/mtp/MtpDescriptors.h

0 → 100644
+96 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef MTP_DESCRIPTORS_H

#define MTP_DESCRIPTORS_H



#include <linux/usb/ch9.h>

#include <linux/usb/functionfs.h>

#include <sys/endian.h>



namespace android {



constexpr int MAX_PACKET_SIZE_FS = 64;

constexpr int MAX_PACKET_SIZE_HS = 512;

constexpr int MAX_PACKET_SIZE_SS = 1024;

constexpr int MAX_PACKET_SIZE_EV = 28;



struct func_desc {

    struct usb_interface_descriptor intf;

    struct usb_endpoint_descriptor_no_audio sink;

    struct usb_endpoint_descriptor_no_audio source;

    struct usb_endpoint_descriptor_no_audio intr;

} __attribute__((packed));



struct ss_func_desc {

    struct usb_interface_descriptor intf;

    struct usb_endpoint_descriptor_no_audio sink;

    struct usb_ss_ep_comp_descriptor sink_comp;

    struct usb_endpoint_descriptor_no_audio source;

    struct usb_ss_ep_comp_descriptor source_comp;

    struct usb_endpoint_descriptor_no_audio intr;

    struct usb_ss_ep_comp_descriptor intr_comp;

} __attribute__((packed));



struct desc_v1 {

    struct usb_functionfs_descs_head_v1 {

        __le32 magic;

        __le32 length;

        __le32 fs_count;

        __le32 hs_count;

    } __attribute__((packed)) header;

    struct func_desc fs_descs, hs_descs;

} __attribute__((packed));



struct desc_v2 {

    struct usb_functionfs_descs_head_v2 header;

    // The rest of the structure depends on the flags in the header.

    __le32 fs_count;

    __le32 hs_count;

    __le32 ss_count;

    __le32 os_count;

    struct func_desc fs_descs, hs_descs;

    struct ss_func_desc ss_descs;

    struct usb_os_desc_header os_header;

    struct usb_ext_compat_desc os_desc;

} __attribute__((packed));



// OS descriptor contents should not be changed. See b/64790536.

static_assert(sizeof(struct desc_v2) == sizeof(usb_functionfs_descs_head_v2) +

        16 + 2 * sizeof(struct func_desc) + sizeof(struct ss_func_desc) +

        sizeof(usb_os_desc_header) + sizeof(usb_ext_compat_desc),

        "Size of mtp descriptor is incorrect!");



#define STR_INTERFACE "MTP"

struct functionfs_lang {

    __le16 code;

    char str1[sizeof(STR_INTERFACE)];

} __attribute__((packed));



struct functionfs_strings {

    struct usb_functionfs_strings_head header;

    struct functionfs_lang lang0;

} __attribute__((packed));



extern const struct desc_v2 mtp_desc_v2;

extern const struct desc_v2 ptp_desc_v2;

extern const struct desc_v1 mtp_desc_v1;

extern const struct desc_v1 ptp_desc_v1;

extern const struct functionfs_strings mtp_strings;



}; // namespace android



#endif // MTP_DESCRIPTORS_H

media/mtp/MtpFfsHandle.cpp

+23 −278
Original line number Diff line number Diff line
@@ -20,13 +20,10 @@ 
#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <linux/usb/ch9.h>

#include <linux/usb/functionfs.h>

#include <memory>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/endian.h>

#include <sys/eventfd.h>

#include <sys/ioctl.h>

#include <sys/mman.h>
@@ -36,6 +33,7 @@ 
#include <unistd.h>



#include "PosixAsyncIO.h"

#include "MtpDescriptors.h"

#include "MtpFfsHandle.h"

#include "mtp.h"
@@ -45,11 +43,6 @@ constexpr char FFS_MTP_EP_IN[] = "/dev/usb-ffs/mtp/ep1"; 
constexpr char FFS_MTP_EP_OUT[] = "/dev/usb-ffs/mtp/ep2";

constexpr char FFS_MTP_EP_INTR[] = "/dev/usb-ffs/mtp/ep3";



constexpr int MAX_PACKET_SIZE_FS = 64;

constexpr int MAX_PACKET_SIZE_HS = 512;

constexpr int MAX_PACKET_SIZE_SS = 1024;

constexpr int MAX_PACKET_SIZE_EV = 28;



constexpr unsigned AIO_BUFS_MAX = 128;

constexpr unsigned AIO_BUF_LEN = 16384;
@@ -61,234 +54,6 @@ constexpr uint32_t MAX_MTP_FILE_SIZE = 0xFFFFFFFF; 


struct timespec ZERO_TIMEOUT = { 0, 0 };



struct func_desc {

    struct usb_interface_descriptor intf;

    struct usb_endpoint_descriptor_no_audio sink;

    struct usb_endpoint_descriptor_no_audio source;

    struct usb_endpoint_descriptor_no_audio intr;

} __attribute__((packed));



struct ss_func_desc {

    struct usb_interface_descriptor intf;

    struct usb_endpoint_descriptor_no_audio sink;

    struct usb_ss_ep_comp_descriptor sink_comp;

    struct usb_endpoint_descriptor_no_audio source;

    struct usb_ss_ep_comp_descriptor source_comp;

    struct usb_endpoint_descriptor_no_audio intr;

    struct usb_ss_ep_comp_descriptor intr_comp;

} __attribute__((packed));



struct desc_v1 {

    struct usb_functionfs_descs_head_v1 {

        __le32 magic;

        __le32 length;

        __le32 fs_count;

        __le32 hs_count;

    } __attribute__((packed)) header;

    struct func_desc fs_descs, hs_descs;

} __attribute__((packed));



struct desc_v2 {

    struct usb_functionfs_descs_head_v2 header;

    // The rest of the structure depends on the flags in the header.

    __le32 fs_count;

    __le32 hs_count;

    __le32 ss_count;

    __le32 os_count;

    struct func_desc fs_descs, hs_descs;

    struct ss_func_desc ss_descs;

    struct usb_os_desc_header os_header;

    struct usb_ext_compat_desc os_desc;

} __attribute__((packed));



const struct usb_interface_descriptor mtp_interface_desc = {

    .bLength = USB_DT_INTERFACE_SIZE,

    .bDescriptorType = USB_DT_INTERFACE,

    .bInterfaceNumber = 0,

    .bNumEndpoints = 3,

    .bInterfaceClass = USB_CLASS_STILL_IMAGE,

    .bInterfaceSubClass = 1,

    .bInterfaceProtocol = 1,

    .iInterface = 1,

};



const struct usb_interface_descriptor ptp_interface_desc = {

    .bLength = USB_DT_INTERFACE_SIZE,

    .bDescriptorType = USB_DT_INTERFACE,

    .bInterfaceNumber = 0,

    .bNumEndpoints = 3,

    .bInterfaceClass = USB_CLASS_STILL_IMAGE,

    .bInterfaceSubClass = 1,

    .bInterfaceProtocol = 1,

};



const struct usb_endpoint_descriptor_no_audio fs_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_FS,

};



const struct usb_endpoint_descriptor_no_audio fs_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_FS,

};



const struct usb_endpoint_descriptor_no_audio intr = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 3 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_INT,

    .wMaxPacketSize = MAX_PACKET_SIZE_EV,

    .bInterval = 6,

};



const struct usb_endpoint_descriptor_no_audio hs_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_HS,

};



const struct usb_endpoint_descriptor_no_audio hs_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_HS,

};



const struct usb_endpoint_descriptor_no_audio ss_sink = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 1 | USB_DIR_IN,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_SS,

};



const struct usb_endpoint_descriptor_no_audio ss_source = {

    .bLength = USB_DT_ENDPOINT_SIZE,

    .bDescriptorType = USB_DT_ENDPOINT,

    .bEndpointAddress = 2 | USB_DIR_OUT,

    .bmAttributes = USB_ENDPOINT_XFER_BULK,

    .wMaxPacketSize = MAX_PACKET_SIZE_SS,

};



const struct usb_ss_ep_comp_descriptor ss_sink_comp = {

    .bLength = sizeof(ss_sink_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

    .bMaxBurst = 6,

};



const struct usb_ss_ep_comp_descriptor ss_source_comp = {

    .bLength = sizeof(ss_source_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

    .bMaxBurst = 6,

};



const struct usb_ss_ep_comp_descriptor ss_intr_comp = {

    .bLength = sizeof(ss_intr_comp),

    .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,

};



const struct func_desc mtp_fs_descriptors = {

    .intf = mtp_interface_desc,

    .sink = fs_sink,

    .source = fs_source,

    .intr = intr,

};



const struct func_desc mtp_hs_descriptors = {

    .intf = mtp_interface_desc,

    .sink = hs_sink,

    .source = hs_source,

    .intr = intr,

};



const struct ss_func_desc mtp_ss_descriptors = {

    .intf = mtp_interface_desc,

    .sink = ss_sink,

    .sink_comp = ss_sink_comp,

    .source = ss_source,

    .source_comp = ss_source_comp,

    .intr = intr,

    .intr_comp = ss_intr_comp,

};



const struct func_desc ptp_fs_descriptors = {

    .intf = ptp_interface_desc,

    .sink = fs_sink,

    .source = fs_source,

    .intr = intr,

};



const struct func_desc ptp_hs_descriptors = {

    .intf = ptp_interface_desc,

    .sink = hs_sink,

    .source = hs_source,

    .intr = intr,

};



const struct ss_func_desc ptp_ss_descriptors = {

    .intf = ptp_interface_desc,

    .sink = ss_sink,

    .sink_comp = ss_sink_comp,

    .source = ss_source,

    .source_comp = ss_source_comp,

    .intr = intr,

    .intr_comp = ss_intr_comp,

};



#define STR_INTERFACE "MTP"

const struct {

    struct usb_functionfs_strings_head header;

    struct {

        __le16 code;

        const char str1[sizeof(STR_INTERFACE)];

    } __attribute__((packed)) lang0;

} __attribute__((packed)) strings = {

    .header = {

        .magic = htole32(FUNCTIONFS_STRINGS_MAGIC),

        .length = htole32(sizeof(strings)),

        .str_count = htole32(1),

        .lang_count = htole32(1),

    },

    .lang0 = {

        .code = htole16(0x0409),

        .str1 = STR_INTERFACE,

    },

};



struct usb_os_desc_header mtp_os_desc_header = {

    .interface = htole32(1),

    .dwLength = htole32(sizeof(usb_os_desc_header) + sizeof(usb_ext_compat_desc)),

    .bcdVersion = htole16(1),

    .wIndex = htole16(4),

    .bCount = htole16(1),

    .Reserved = htole16(0),

};



struct usb_ext_compat_desc mtp_os_desc_compat = {

    .bFirstInterfaceNumber = 0,

    .Reserved1 = htole32(1),

    .CompatibleID = { 'M', 'T', 'P' },

    .SubCompatibleID = {0},

    .Reserved2 = {0},

};



struct usb_ext_compat_desc ptp_os_desc_compat = {

    .bFirstInterfaceNumber = 0,

    .Reserved1 = htole32(1),

    .CompatibleID = { 'P', 'T', 'P' },

    .SubCompatibleID = {0},

    .Reserved2 = {0},

};



struct mtp_device_status {

    uint16_t  wLength;

    uint16_t  wCode;
@@ -357,58 +122,38 @@ void MtpFfsHandle::advise(int fd) { 
}



bool MtpFfsHandle::initFunctionfs() {

    ssize_t ret;

    struct desc_v1 v1_descriptor;

    struct desc_v2 v2_descriptor;



    v2_descriptor.header.magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2);

    v2_descriptor.header.length = htole32(sizeof(v2_descriptor));

    v2_descriptor.header.flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC |

                                 FUNCTIONFS_HAS_SS_DESC | FUNCTIONFS_HAS_MS_OS_DESC;

    v2_descriptor.fs_count = 4;

    v2_descriptor.hs_count = 4;

    v2_descriptor.ss_count = 7;

    v2_descriptor.os_count = 1;

    v2_descriptor.fs_descs = mPtp ? ptp_fs_descriptors : mtp_fs_descriptors;

    v2_descriptor.hs_descs = mPtp ? ptp_hs_descriptors : mtp_hs_descriptors;

    v2_descriptor.ss_descs = mPtp ? ptp_ss_descriptors : mtp_ss_descriptors;

    v2_descriptor.os_header = mtp_os_desc_header;

    v2_descriptor.os_desc = mPtp ? ptp_os_desc_compat : mtp_os_desc_compat;



    if (mControl < 0) { // might have already done this before

        mControl.reset(TEMP_FAILURE_RETRY(open(FFS_MTP_EP0, O_RDWR)));

        if (mControl < 0) {

            PLOG(ERROR) << FFS_MTP_EP0 << ": cannot open control endpoint";

            goto err;

            return false;

        }

        if (!writeDescriptors()) {

            closeConfig();

            return false;

        }

    }

    return true;

}



        ret = TEMP_FAILURE_RETRY(::write(mControl, &v2_descriptor, sizeof(v2_descriptor)));

bool MtpFfsHandle::writeDescriptors() {

    ssize_t ret = TEMP_FAILURE_RETRY(::write(mControl,

                &(mPtp ? ptp_desc_v2 : mtp_desc_v2), sizeof(desc_v2)));

    if (ret < 0) {

            v1_descriptor.header.magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC);

            v1_descriptor.header.length = htole32(sizeof(v1_descriptor));

            v1_descriptor.header.fs_count = 4;

            v1_descriptor.header.hs_count = 4;

            v1_descriptor.fs_descs = mPtp ? ptp_fs_descriptors : mtp_fs_descriptors;

            v1_descriptor.hs_descs = mPtp ? ptp_hs_descriptors : mtp_hs_descriptors;

        PLOG(ERROR) << FFS_MTP_EP0 << "Switching to V1 descriptor format";

            ret = TEMP_FAILURE_RETRY(::write(mControl, &v1_descriptor, sizeof(v1_descriptor)));

        ret = TEMP_FAILURE_RETRY(::write(mControl,

                    &(mPtp ? ptp_desc_v1 : mtp_desc_v1), sizeof(desc_v1)));

        if (ret < 0) {

            PLOG(ERROR) << FFS_MTP_EP0 << "Writing descriptors failed";

                goto err;

            return false;

        }

    }

        ret = TEMP_FAILURE_RETRY(::write(mControl, &strings, sizeof(strings)));

    ret = TEMP_FAILURE_RETRY(::write(mControl, &mtp_strings, sizeof(mtp_strings)));

    if (ret < 0) {

        PLOG(ERROR) << FFS_MTP_EP0 << "Writing strings failed";

            goto err;

        }

        return false;

    }



    return true;



err:

    closeConfig();

    return false;

}



void MtpFfsHandle::closeConfig() {

media/mtp/MtpFfsHandle.h

+4 −1
Original line number Diff line number Diff line
@@ -42,11 +42,14 @@ struct io_buffer { 
};



template <class T> class MtpFfsHandleTest;

template <class T> class MtpFfsHandleTest_testControl_Test;



class MtpFfsHandle : public IMtpHandle {

    template <class T> friend class android::MtpFfsHandleTest;

    template <class T> friend class MtpFfsHandleTest;

    template <class T> friend class MtpFfsHandleTest_testControl_Test;

protected:

    bool initFunctionfs();

    bool writeDescriptors();

    void closeConfig();

    void closeEndpoints();

    void advise(int fd);