bianbu-linux
/
buildroot
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update for v1.0

This commit is contained in:
James Deng 2024-05-30 23:19:44 +08:00
parent 175d273b48
commit 7a6b679ab3
2 changed files with 497 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

384
package/android-tools/0011-add-super-speed-desc.patch Normal file
View File

@ -0,0 +1,384 @@
From 0cc2b11774cd38f1fd205a643fc5219ad25f7fb0 Mon Sep 17 00:00:00 2001
From: "minda.chen" <minda.chen@starfivetech.com>
Date: Thu, 18 Aug 2022 14:40:31 +0800
Subject: [PATCH] add super speed desc
Signed-off-by: minda.chen <minda.chen@starfivetech.com>
---
core/adbd/functionfs.h | 57 +++++++-
core/adbd/usb_linux_client.c | 244 +++++++++++++++++++++++++----------
2 files changed, 228 insertions(+), 73 deletions(-)
diff --git a/core/adbd/functionfs.h b/core/adbd/functionfs.h
index 53a3f30..bc40654 100644
--- a/core/adbd/functionfs.h
+++ b/core/adbd/functionfs.h
@@ -10,11 +10,10 @@
enum {
FUNCTIONFS_DESCRIPTORS_MAGIC = 1,
- FUNCTIONFS_STRINGS_MAGIC = 2
+ FUNCTIONFS_STRINGS_MAGIC = 2,
+ FUNCTIONFS_DESCRIPTORS_MAGIC_V2 = 3,
};
-
-
/* Descriptor of an non-audio endpoint */
struct usb_endpoint_descriptor_no_audio {
__u8 bLength;
@@ -163,5 +162,57 @@ struct usb_functionfs_event {
#define FUNCTIONFS_ENDPOINT_REVMAP _IO('g', 129)
+enum functionfs_flags {
+ FUNCTIONFS_HAS_FS_DESC = 1,
+ FUNCTIONFS_HAS_HS_DESC = 2,
+ FUNCTIONFS_HAS_SS_DESC = 4,
+ FUNCTIONFS_HAS_MS_OS_DESC = 8,
+ FUNCTIONFS_VIRTUAL_ADDR = 16,
+ FUNCTIONFS_EVENTFD = 32,
+ FUNCTIONFS_ALL_CTRL_RECIP = 64,
+ FUNCTIONFS_CONFIG0_SETUP = 128,
+};
+
+
+struct usb_functionfs_descs_head_v2 {
+ __le32 magic;
+ __le32 length;
+ __le32 flags;
+ /*
+ * __le32 fs_count, hs_count, fs_count; must be included manually in
+ * the structure taking flags into consideration.
+ */
+} __attribute__((packed));
+
+
+/* MS OS Descriptor header */
+struct usb_os_desc_header {
+ __u8 interface;
+ __le32 dwLength;
+ __le16 bcdVersion;
+ __le16 wIndex;
+ union {
+ struct {
+ __u8 bCount;
+ __u8 Reserved;
+ };
+ __le16 wCount;
+ };
+} __attribute__((packed));
+
+struct usb_ext_compat_desc {
+ __u8 bFirstInterfaceNumber;
+ __u8 Reserved1;
+ __u8 CompatibleID[8];
+ __u8 SubCompatibleID[8];
+ __u8 Reserved2[6];
+};
+
+struct usb_ext_prop_desc {
+ __le32 dwSize;
+ __le32 dwPropertyDataType;
+ __le16 wPropertyNameLength;
+} __attribute__((packed));
+
#endif
diff --git a/core/adbd/usb_linux_client.c b/core/adbd/usb_linux_client.c
index 0e4d200..eccf45b 100644
--- a/core/adbd/usb_linux_client.c
+++ b/core/adbd/usb_linux_client.c
@@ -33,6 +33,7 @@
#define MAX_PACKET_SIZE_FS 64
#define MAX_PACKET_SIZE_HS 512
+#define MAX_PACKET_SIZE_SS 1024
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define cpu_to_le16(x) (x)
@@ -62,74 +63,56 @@ struct usb_handle
int bulk_in; /* "in" from the host's perspective => sink for adbd */
};
-static const struct {
- struct usb_functionfs_descs_head header;
- struct {
- struct usb_interface_descriptor intf;
- struct usb_endpoint_descriptor_no_audio source;
- struct usb_endpoint_descriptor_no_audio sink;
- } __attribute__((packed)) fs_descs, hs_descs;
-} __attribute__((packed)) descriptors = {
- .header = {
- .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC),
- .length = cpu_to_le32(sizeof(descriptors)),
- .fs_count = 3,
- .hs_count = 3,
- },
- .fs_descs = {
- .intf = {
- .bLength = sizeof(descriptors.fs_descs.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(descriptors.fs_descs.source),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = 1 | USB_DIR_OUT,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize = MAX_PACKET_SIZE_FS,
- },
- .sink = {
- .bLength = sizeof(descriptors.fs_descs.sink),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = 2 | USB_DIR_IN,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize = MAX_PACKET_SIZE_FS,
- },
- },
- .hs_descs = {
- .intf = {
- .bLength = sizeof(descriptors.hs_descs.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(descriptors.hs_descs.source),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = 1 | USB_DIR_OUT,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize = MAX_PACKET_SIZE_HS,
- },
- .sink = {
- .bLength = sizeof(descriptors.hs_descs.sink),
- .bDescriptorType = USB_DT_ENDPOINT,
- .bEndpointAddress = 2 | USB_DIR_IN,
- .bmAttributes = USB_ENDPOINT_XFER_BULK,
- .wMaxPacketSize = MAX_PACKET_SIZE_HS,
- },
- },
+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));
+
+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));
+
+static struct func_desc fs_descriptors;
+static struct func_desc hs_descriptors;
+static struct ss_func_desc ss_descriptors;
+
+struct usb_ext_compat_desc os_desc_compat = {
+ .bFirstInterfaceNumber = 0,
+ .Reserved1 = cpu_to_le32(1),
+ .CompatibleID = {0},
+ .SubCompatibleID = {0},
+ .Reserved2 = {0},
};
+static struct usb_os_desc_header os_desc_header;
#define STR_INTERFACE_ "ADB Interface"
static const struct {
@@ -151,10 +134,103 @@ static const struct {
},
};
+static void init_fs_descriptors(void)
+{
+ fs_descriptors.intf.bLength = sizeof(fs_descriptors.intf);
+ fs_descriptors.intf.bDescriptorType = USB_DT_INTERFACE;
+ fs_descriptors.intf.bInterfaceNumber = 0;
+ fs_descriptors.intf.bNumEndpoints = 2;
+ fs_descriptors.intf.bInterfaceClass = ADB_CLASS;
+ fs_descriptors.intf.bInterfaceSubClass = ADB_SUBCLASS;
+ fs_descriptors.intf.bInterfaceProtocol = ADB_PROTOCOL;
+ fs_descriptors.intf.iInterface = 1; /* first string from the provided table */
+
+ fs_descriptors.source.bLength = sizeof(fs_descriptors.source);
+ fs_descriptors.source.bDescriptorType = USB_DT_ENDPOINT;
+ fs_descriptors.source.bEndpointAddress = 1 | USB_DIR_OUT;
+ fs_descriptors.source.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ fs_descriptors.source.wMaxPacketSize = MAX_PACKET_SIZE_FS;
+
+ fs_descriptors.sink.bLength = sizeof(fs_descriptors.sink);
+ fs_descriptors.sink.bDescriptorType = USB_DT_ENDPOINT;
+ fs_descriptors.sink.bEndpointAddress = 2 | USB_DIR_IN;
+ fs_descriptors.sink.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ fs_descriptors.sink.wMaxPacketSize = MAX_PACKET_SIZE_FS;
+}
+static void init_hs_descriptors(void)
+{
+ hs_descriptors.intf.bLength = sizeof(hs_descriptors.intf);
+ hs_descriptors.intf.bDescriptorType = USB_DT_INTERFACE;
+ hs_descriptors.intf.bInterfaceNumber = 0;
+ hs_descriptors.intf.bNumEndpoints = 2;
+ hs_descriptors.intf.bInterfaceClass = ADB_CLASS;
+ hs_descriptors.intf.bInterfaceSubClass = ADB_SUBCLASS;
+ hs_descriptors.intf.bInterfaceProtocol = ADB_PROTOCOL;
+ hs_descriptors.intf.iInterface = 1; /* first string from the provided table */
+
+ hs_descriptors.source.bLength = sizeof(hs_descriptors.source);
+ hs_descriptors.source.bDescriptorType = USB_DT_ENDPOINT;
+ hs_descriptors.source.bEndpointAddress = 1 | USB_DIR_OUT;
+ hs_descriptors.source.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ hs_descriptors.source.wMaxPacketSize = MAX_PACKET_SIZE_HS;
+
+ hs_descriptors.sink.bLength = sizeof(hs_descriptors.sink);
+ hs_descriptors.sink.bDescriptorType = USB_DT_ENDPOINT;
+ hs_descriptors.sink.bEndpointAddress = 2 | USB_DIR_IN;
+ hs_descriptors.sink.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ hs_descriptors.sink.wMaxPacketSize = MAX_PACKET_SIZE_HS;
+}
-static void *usb_adb_open_thread(void *x)
+static void init_ss_descriptors(void)
{
+ ss_descriptors.intf.bLength = sizeof(ss_descriptors.intf);
+ ss_descriptors.intf.bDescriptorType = USB_DT_INTERFACE;
+ ss_descriptors.intf.bInterfaceNumber = 0;
+ ss_descriptors.intf.bNumEndpoints = 2;
+ ss_descriptors.intf.bInterfaceClass = ADB_CLASS;
+ ss_descriptors.intf.bInterfaceSubClass = ADB_SUBCLASS;
+ ss_descriptors.intf.bInterfaceProtocol = ADB_PROTOCOL;
+ ss_descriptors.intf.iInterface = 1; /* first string from the provided table */
+
+ ss_descriptors.source.bLength = sizeof(ss_descriptors.source);
+ ss_descriptors.source.bDescriptorType = USB_DT_ENDPOINT;
+ ss_descriptors.source.bEndpointAddress = 1 | USB_DIR_OUT;
+ ss_descriptors.source.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ ss_descriptors.source.wMaxPacketSize = MAX_PACKET_SIZE_SS;
+
+ ss_descriptors.source_comp.bLength = sizeof(ss_descriptors.source_comp);
+ ss_descriptors.source_comp.bDescriptorType = USB_DT_SS_ENDPOINT_COMP;
+
+ ss_descriptors.sink.bLength = sizeof(ss_descriptors.sink);
+ ss_descriptors.sink.bDescriptorType = USB_DT_ENDPOINT;
+ ss_descriptors.sink.bEndpointAddress = 2 | USB_DIR_IN;
+ ss_descriptors.sink.bmAttributes = USB_ENDPOINT_XFER_BULK;
+ ss_descriptors.sink.wMaxPacketSize = MAX_PACKET_SIZE_SS;
+
+ ss_descriptors.sink_comp.bLength = sizeof(ss_descriptors.sink_comp);
+ ss_descriptors.sink_comp.bDescriptorType = USB_DT_SS_ENDPOINT_COMP;
+}
+
+static void init_os_desc_header(void)
+{
+ os_desc_header.interface = cpu_to_le32(1);
+ os_desc_header.dwLength = cpu_to_le32(sizeof(os_desc_header) + sizeof(os_desc_compat));
+ os_desc_header.bcdVersion = cpu_to_le32(1);
+ os_desc_header.wIndex = cpu_to_le32(4);
+ os_desc_header.bCount = cpu_to_le32(1);
+ os_desc_header.Reserved = cpu_to_le32(0);
+}
+
+static void init_structs(void)
+{
+ init_fs_descriptors();
+ init_hs_descriptors();
+ init_ss_descriptors();
+ init_os_desc_header();
+}
+
+static void *usb_adb_open_thread(void *x) {
struct usb_handle *usb = (struct usb_handle *)x;
int fd;
@@ -270,15 +346,42 @@ static void usb_adb_init()
static void init_functionfs(struct usb_handle *h)
{
ssize_t ret;
-
- D("OPENING %s\n", USB_FFS_ADB_EP0);
+ 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 = 1;
+ 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;
+
+ D("OPENING %s", USB_FFS_ADB_EP0);
h->control = adb_open(USB_FFS_ADB_EP0, O_RDWR);
if (h->control < 0) {
D("[ %s: cannot open control endpoint: errno=%d]\n", USB_FFS_ADB_EP0, errno);
goto err;
}
- ret = adb_write(h->control, &descriptors, sizeof(descriptors));
+ ret = adb_write(h->control, &v2_descriptor, sizeof(v2_descriptor));
+ if (ret < 0 && errno == EINVAL) {
+ 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;
+ D("[ %s: Switching to V1_descriptor format errno=%d ]", USB_FFS_ADB_EP0, errno);
+ ret = adb_write(h->control, &v1_descriptor, sizeof(v1_descriptor));
+ }
+
if (ret < 0) {
D("[ %s: write descriptors failed: errno=%d ]\n", USB_FFS_ADB_EP0, errno);
goto err;
@@ -469,6 +572,7 @@ static void usb_ffs_init()
void usb_init()
{
+ init_structs();
if (access(USB_FFS_ADB_EP0, F_OK) == 0)
usb_ffs_init();
else
--
2.17.1

113
package/android-tools/0012-fix-mount-adb-devices-issue.patch Normal file
View File

@ -0,0 +1,113 @@
From ce9bc4f0ab892431c475577be825816fea5a2dd8 Mon Sep 17 00:00:00 2001
From: "minda.chen" <minda.chen@starfivetech.com>
Date: Fri, 19 Aug 2022 09:47:28 +0800
Subject: [PATCH] fix mount adb devices issue
Signed-off-by: minda.chen <minda.chen@starfivetech.com>
---
core/adbd/usb_linux_client.c | 64 ++++++++++++++++++++----------------
1 file changed, 35 insertions(+), 29 deletions(-)
diff --git a/core/adbd/usb_linux_client.c b/core/adbd/usb_linux_client.c
index eccf45b..6875394 100644
--- a/core/adbd/usb_linux_client.c
+++ b/core/adbd/usb_linux_client.c
@@ -363,34 +363,36 @@ static void init_functionfs(struct usb_handle *h)
v2_descriptor.os_header = os_desc_header;
v2_descriptor.os_desc = os_desc_compat;
- D("OPENING %s", USB_FFS_ADB_EP0);
- h->control = adb_open(USB_FFS_ADB_EP0, O_RDWR);
if (h->control < 0) {
- D("[ %s: cannot open control endpoint: errno=%d]\n", USB_FFS_ADB_EP0, errno);
- goto err;
- }
-
- ret = adb_write(h->control, &v2_descriptor, sizeof(v2_descriptor));
- if (ret < 0 && errno == EINVAL) {
- 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;
- D("[ %s: Switching to V1_descriptor format errno=%d ]", USB_FFS_ADB_EP0, errno);
- ret = adb_write(h->control, &v1_descriptor, sizeof(v1_descriptor));
- }
+ D("OPENING %s", USB_FFS_ADB_EP0);
+ h->control = adb_open(USB_FFS_ADB_EP0, O_RDWR);
+ if (h->control < 0) {
+ D("[ %s: cannot open control endpoint: errno=%d]\n", USB_FFS_ADB_EP0, errno);
+ goto err;
+ }
+
+ ret = adb_write(h->control, &v2_descriptor, sizeof(v2_descriptor));
+ if (ret < 0 && errno == EINVAL) {
+ 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;
+ D("[ %s: Switching to V1_descriptor format errno=%d ]", USB_FFS_ADB_EP0, errno);
+ ret = adb_write(h->control, &v1_descriptor, sizeof(v1_descriptor));
+ }
- if (ret < 0) {
- D("[ %s: write descriptors failed: errno=%d ]\n", USB_FFS_ADB_EP0, errno);
- goto err;
- }
+ if (ret < 0) {
+ D("[ %s: write descriptors failed: errno=%d ]\n", USB_FFS_ADB_EP0, errno);
+ goto err;
+ }
- ret = adb_write(h->control, &strings, sizeof(strings));
- if (ret < 0) {
- D("[ %s: writing strings failed: errno=%d]\n", USB_FFS_ADB_EP0, errno);
- goto err;
+ ret = adb_write(h->control, &strings, sizeof(strings));
+ if (ret < 0) {
+ D("[ %s: writing strings failed: errno=%d]\n", USB_FFS_ADB_EP0, errno);
+ goto err;
+ }
}
h->bulk_out = adb_open(USB_FFS_ADB_OUT, O_RDWR);
@@ -430,14 +432,14 @@ static void *usb_ffs_open_thread(void *x)
while (1) {
// wait until the USB device needs opening
adb_mutex_lock(&usb->lock);
- while (usb->control != -1)
+ while (usb->control != -1 && usb->bulk_in != -1 && usb->bulk_out != -1)
adb_cond_wait(&usb->notify, &usb->lock);
adb_mutex_unlock(&usb->lock);
while (1) {
init_functionfs(usb);
- if (usb->control >= 0)
+ if (usb->control >= 0 && usb->bulk_in >= 0 && usb->bulk_out >= 0)
break;
adb_sleep_ms(1000);
@@ -534,10 +536,14 @@ static void usb_ffs_kick(usb_handle *h)
D("[ kick: sink (fd=%d) clear halt failed (%d) ]", h->bulk_out, errno);
adb_mutex_lock(&h->lock);
- adb_close(h->control);
+
+ // don't close ep0 here, since we may not need to reinitialize it with
+ // the same descriptors again. if however ep1/ep2 fail to re-open in
+ // init_functionfs, only then would we close and open ep0 again.
+
adb_close(h->bulk_out);
adb_close(h->bulk_in);
- h->control = h->bulk_out = h->bulk_in = -1;
+ h->bulk_out = h->bulk_in = -1;
// notify usb_ffs_open_thread that we are disconnected
adb_cond_signal(&h->notify);
--
2.17.1