b310da608b
The MS OS extended property descriptor is used to convey additional
information to Windows hosts, in this case the DeviceInterfaceGUID
which allows the inbox WinUSB driver to get automatically installed.
However, the ADB windows client looks for USB devices by enumerating
devices with a specific GUID {F72FE0D4-CBCB-407D-8814-9ED673D0DD6B},
and as a result fails to find the device since it was installed with
a different DeviceInterfaceGUID. Update the OS descriptor to pass
back the same GUID the client already uses.
Change-Id: If664cdd9be821c502e8c2048ff79e79e311936f5
320 lines
11 KiB
C++
320 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2018 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.
|
|
*/
|
|
|
|
#define TRACE_TAG USB
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include <linux/usb/ch9.h>
|
|
#include <linux/usb/functionfs.h>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/unique_fd.h>
|
|
|
|
#include "adb.h"
|
|
#include "adbd/usb.h"
|
|
|
|
#define MAX_PACKET_SIZE_FS 64
|
|
#define MAX_PACKET_SIZE_HS 512
|
|
#define MAX_PACKET_SIZE_SS 1024
|
|
|
|
#define USB_FFS_BULK_SIZE 16384
|
|
|
|
// Number of buffers needed to fit MAX_PAYLOAD, with an extra for ZLPs.
|
|
#define USB_FFS_NUM_BUFS ((4 * MAX_PAYLOAD / USB_FFS_BULK_SIZE) + 1)
|
|
|
|
#define USB_EXT_PROP_UNICODE 1
|
|
|
|
#define cpu_to_le16(x) htole16(x)
|
|
#define cpu_to_le32(x) htole32(x)
|
|
|
|
// clang-format off
|
|
struct func_desc {
|
|
struct usb_interface_descriptor intf;
|
|
struct usb_endpoint_descriptor_no_audio source;
|
|
struct usb_endpoint_descriptor_no_audio sink;
|
|
} __attribute__((packed));
|
|
|
|
struct ss_func_desc {
|
|
struct usb_interface_descriptor intf;
|
|
struct usb_endpoint_descriptor_no_audio source;
|
|
struct usb_ss_ep_comp_descriptor source_comp;
|
|
struct usb_endpoint_descriptor_no_audio sink;
|
|
struct usb_ss_ep_comp_descriptor sink_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));
|
|
|
|
template <size_t PropertyNameLength, size_t PropertyDataLength>
|
|
struct usb_os_desc_ext_prop {
|
|
uint32_t dwSize = sizeof(*this);
|
|
uint32_t dwPropertyDataType = cpu_to_le32(USB_EXT_PROP_UNICODE);
|
|
|
|
// Property name and value are transmitted as UTF-16, but the kernel only
|
|
// accepts ASCII values and performs the conversion for us.
|
|
uint16_t wPropertyNameLength = cpu_to_le16(PropertyNameLength);
|
|
char bPropertyName[PropertyNameLength];
|
|
|
|
uint32_t dwPropertyDataLength = cpu_to_le32(PropertyDataLength);
|
|
char bProperty[PropertyDataLength];
|
|
} __attribute__((packed));
|
|
|
|
using usb_os_desc_guid_t = usb_os_desc_ext_prop<20, 39>;
|
|
usb_os_desc_guid_t os_desc_guid = {
|
|
.bPropertyName = "DeviceInterfaceGUID",
|
|
.bProperty = "{F72FE0D4-CBCB-407D-8814-9ED673D0DD6B}",
|
|
};
|
|
|
|
struct usb_ext_prop_values {
|
|
usb_os_desc_guid_t guid;
|
|
} __attribute__((packed));
|
|
|
|
usb_ext_prop_values os_prop_values = {
|
|
.guid = os_desc_guid,
|
|
};
|
|
|
|
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;
|
|
struct usb_os_desc_header os_prop_header;
|
|
struct usb_ext_prop_values os_prop_values;
|
|
} __attribute__((packed));
|
|
|
|
static struct func_desc fs_descriptors = {
|
|
.intf = {
|
|
.bLength = sizeof(fs_descriptors.intf),
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 0,
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = ADB_CLASS,
|
|
.bInterfaceSubClass = ADB_SUBCLASS,
|
|
.bInterfaceProtocol = ADB_PROTOCOL,
|
|
.iInterface = 1, /* first string from the provided table */
|
|
},
|
|
.source = {
|
|
.bLength = sizeof(fs_descriptors.source),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 1 | USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_FS,
|
|
},
|
|
.sink = {
|
|
.bLength = sizeof(fs_descriptors.sink),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 2 | USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_FS,
|
|
},
|
|
};
|
|
|
|
static struct func_desc hs_descriptors = {
|
|
.intf = {
|
|
.bLength = sizeof(hs_descriptors.intf),
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 0,
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = ADB_CLASS,
|
|
.bInterfaceSubClass = ADB_SUBCLASS,
|
|
.bInterfaceProtocol = ADB_PROTOCOL,
|
|
.iInterface = 1, /* first string from the provided table */
|
|
},
|
|
.source = {
|
|
.bLength = sizeof(hs_descriptors.source),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 1 | USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_HS,
|
|
},
|
|
.sink = {
|
|
.bLength = sizeof(hs_descriptors.sink),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 2 | USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_HS,
|
|
},
|
|
};
|
|
|
|
static struct ss_func_desc ss_descriptors = {
|
|
.intf = {
|
|
.bLength = sizeof(ss_descriptors.intf),
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
.bInterfaceNumber = 0,
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = ADB_CLASS,
|
|
.bInterfaceSubClass = ADB_SUBCLASS,
|
|
.bInterfaceProtocol = ADB_PROTOCOL,
|
|
.iInterface = 1, /* first string from the provided table */
|
|
},
|
|
.source = {
|
|
.bLength = sizeof(ss_descriptors.source),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 1 | USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_SS,
|
|
},
|
|
.source_comp = {
|
|
.bLength = sizeof(ss_descriptors.source_comp),
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
.bMaxBurst = 4,
|
|
},
|
|
.sink = {
|
|
.bLength = sizeof(ss_descriptors.sink),
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
.bEndpointAddress = 2 | USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = MAX_PACKET_SIZE_SS,
|
|
},
|
|
.sink_comp = {
|
|
.bLength = sizeof(ss_descriptors.sink_comp),
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
.bMaxBurst = 4,
|
|
},
|
|
};
|
|
|
|
struct usb_ext_compat_desc os_desc_compat = {
|
|
.bFirstInterfaceNumber = 0,
|
|
.Reserved1 = cpu_to_le32(1),
|
|
.CompatibleID = { 'W', 'I', 'N', 'U', 'S', 'B', '\0', '\0'},
|
|
.SubCompatibleID = {0},
|
|
.Reserved2 = {0},
|
|
};
|
|
|
|
static struct usb_os_desc_header os_desc_header = {
|
|
.interface = cpu_to_le32(0),
|
|
.dwLength = cpu_to_le32(sizeof(os_desc_header) + sizeof(os_desc_compat)),
|
|
.bcdVersion = cpu_to_le32(1),
|
|
.wIndex = cpu_to_le32(4),
|
|
.bCount = cpu_to_le32(1),
|
|
.Reserved = cpu_to_le32(0),
|
|
};
|
|
|
|
static struct usb_os_desc_header os_prop_header = {
|
|
.interface = cpu_to_le32(0),
|
|
.dwLength = cpu_to_le32(sizeof(os_desc_header) + sizeof(os_prop_values)),
|
|
.bcdVersion = cpu_to_le32(1),
|
|
.wIndex = cpu_to_le32(5),
|
|
.wCount = cpu_to_le16(1),
|
|
};
|
|
|
|
#define STR_INTERFACE_ "ADB Interface"
|
|
|
|
static 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 = cpu_to_le32(FUNCTIONFS_STRINGS_MAGIC),
|
|
.length = cpu_to_le32(sizeof(strings)),
|
|
.str_count = cpu_to_le32(1),
|
|
.lang_count = cpu_to_le32(1),
|
|
},
|
|
.lang0 = {
|
|
cpu_to_le16(0x0409), /* en-us */
|
|
STR_INTERFACE_,
|
|
},
|
|
};
|
|
// clang-format on
|
|
|
|
bool open_functionfs(android::base::unique_fd* out_control, android::base::unique_fd* out_bulk_out,
|
|
android::base::unique_fd* out_bulk_in) {
|
|
unique_fd control, bulk_out, bulk_in;
|
|
struct desc_v1 v1_descriptor = {};
|
|
struct desc_v2 v2_descriptor = {};
|
|
|
|
v2_descriptor.header.magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2);
|
|
v2_descriptor.header.length = cpu_to_le32(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 = 3;
|
|
v2_descriptor.hs_count = 3;
|
|
v2_descriptor.ss_count = 5;
|
|
v2_descriptor.os_count = 2;
|
|
v2_descriptor.fs_descs = fs_descriptors;
|
|
v2_descriptor.hs_descs = hs_descriptors;
|
|
v2_descriptor.ss_descs = ss_descriptors;
|
|
v2_descriptor.os_header = os_desc_header;
|
|
v2_descriptor.os_desc = os_desc_compat;
|
|
v2_descriptor.os_prop_header = os_prop_header;
|
|
v2_descriptor.os_prop_values = os_prop_values;
|
|
|
|
if (out_control->get() < 0) { // might have already done this before
|
|
LOG(INFO) << "opening control endpoint " << USB_FFS_ADB_EP0;
|
|
control.reset(adb_open(USB_FFS_ADB_EP0, O_RDWR));
|
|
if (control < 0) {
|
|
PLOG(ERROR) << "cannot open control endpoint " << USB_FFS_ADB_EP0;
|
|
return false;
|
|
}
|
|
|
|
if (adb_write(control.get(), &v2_descriptor, sizeof(v2_descriptor)) < 0) {
|
|
D("[ %s: Switching to V1_descriptor format errno=%s ]", USB_FFS_ADB_EP0,
|
|
strerror(errno));
|
|
v1_descriptor.header.magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC);
|
|
v1_descriptor.header.length = cpu_to_le32(sizeof(v1_descriptor));
|
|
v1_descriptor.header.fs_count = 3;
|
|
v1_descriptor.header.hs_count = 3;
|
|
v1_descriptor.fs_descs = fs_descriptors;
|
|
v1_descriptor.hs_descs = hs_descriptors;
|
|
if (adb_write(control.get(), &v1_descriptor, sizeof(v1_descriptor)) < 0) {
|
|
PLOG(ERROR) << "failed to write USB descriptors";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (adb_write(control.get(), &strings, sizeof(strings)) < 0) {
|
|
PLOG(ERROR) << "failed to write USB strings";
|
|
return false;
|
|
}
|
|
// Signal only when writing the descriptors to ffs
|
|
android::base::SetProperty("sys.usb.ffs.ready", "1");
|
|
}
|
|
|
|
bulk_out.reset(adb_open(USB_FFS_ADB_OUT, O_RDONLY));
|
|
if (bulk_out < 0) {
|
|
PLOG(ERROR) << "cannot open bulk-out endpoint " << USB_FFS_ADB_OUT;
|
|
return false;
|
|
}
|
|
|
|
bulk_in.reset(adb_open(USB_FFS_ADB_IN, O_WRONLY));
|
|
if (bulk_in < 0) {
|
|
PLOG(ERROR) << "cannot open bulk-in endpoint " << USB_FFS_ADB_IN;
|
|
return false;
|
|
}
|
|
|
|
*out_control = std::move(control);
|
|
*out_bulk_in = std::move(bulk_in);
|
|
*out_bulk_out = std::move(bulk_out);
|
|
return true;
|
|
}
|