From 0871824de6c5b868f2a2e67c9b5673cb2181b4c6 Mon Sep 17 00:00:00 2001 From: Josh Gao Date: Fri, 27 Mar 2020 18:09:56 -0700 Subject: [PATCH] Move adbd's legacy USB implementation to fastboot. This code path is effectively dead in adbd, and fastboot's dependency on libadbd makes it hard to refactor adbd's dependencies. Bug: http://b/150317254 Test: built and flashed aosp_walleye-eng Change-Id: I5118136d32fdcbbd011559ed0a4a71e1dc7bf064 --- adb/Android.bp | 17 +-- adb/adb.cpp | 4 + adb/adb.h | 3 +- adb/client/main.cpp | 1 + adb/{ => client}/transport_usb.cpp | 8 +- adb/{ => client}/usb.h | 42 ++++--- adb/client/usb_dispatch.cpp | 3 +- adb/client/usb_libusb.cpp | 5 +- adb/client/usb_linux.cpp | 3 +- adb/client/usb_osx.cpp | 2 + adb/client/usb_windows.cpp | 2 + adb/daemon/usb.cpp | 30 +---- adb/daemon/usb_ffs.cpp | 3 +- adb/daemon/{usb_dummy.cpp => usb_ffs.h} | 30 +---- adb/transport.cpp | 2 + adb/transport.h | 37 +++--- fastboot/Android.bp | 2 +- .../usb_legacy.cpp => fastboot/device/usb.cpp | 111 +----------------- .../include/adbd => fastboot/device}/usb.h | 9 +- fastboot/device/usb_client.h | 2 +- 20 files changed, 87 insertions(+), 229 deletions(-) rename adb/{ => client}/transport_usb.cpp (97%) rename adb/{ => client}/usb.h (72%) rename adb/daemon/{usb_dummy.cpp => usb_ffs.h} (52%) rename adb/daemon/usb_legacy.cpp => fastboot/device/usb.cpp (70%) rename {adb/daemon/include/adbd => fastboot/device}/usb.h (84%) diff --git a/adb/Android.bp b/adb/Android.bp index 81d20c1e7..341b7533c 100644 --- a/adb/Android.bp +++ b/adb/Android.bp @@ -133,7 +133,6 @@ libadb_srcs = [ "transport.cpp", "transport_fd.cpp", "transport_local.cpp", - "transport_usb.cpp", "types.cpp", ] @@ -169,6 +168,7 @@ cc_library_host_static { "client/usb_libusb.cpp", "client/usb_dispatch.cpp", "client/transport_mdns.cpp", + "client/transport_usb.cpp", "client/pairing/pairing_client.cpp", ], @@ -382,10 +382,6 @@ cc_library_static { "daemon/adb_wifi.cpp", ], - local_include_dirs: [ - "daemon/include", - ], - generated_headers: ["platform_tools_version"], static_libs: [ @@ -422,12 +418,6 @@ cc_library_static { "daemon/transport_qemu.cpp", "daemon/usb.cpp", "daemon/usb_ffs.cpp", - "daemon/usb_legacy.cpp", - ] - }, - linux_glibc: { - srcs: [ - "daemon/usb_dummy.cpp", ] }, recovery: { @@ -575,8 +565,9 @@ cc_library { "libmdnssd", ], - export_include_dirs: [ - "daemon/include", + visibility: [ + "//bootable/recovery/minadbd", + "//system/core/adb", ], } diff --git a/adb/adb.cpp b/adb/adb.cpp index b5143685a..6c03f7489 100644 --- a/adb/adb.cpp +++ b/adb/adb.cpp @@ -66,6 +66,10 @@ using namespace std::chrono_literals; #include "daemon/logging.h" #endif +#if ADB_HOST +#include "client/usb.h" +#endif + std::string adb_version() { // Don't change the format of this --- it's parsed by ddmlib. return android::base::StringPrintf( diff --git a/adb/adb.h b/adb/adb.h index 9f8d29993..7bc60fca7 100644 --- a/adb/adb.h +++ b/adb/adb.h @@ -29,7 +29,6 @@ #include "fdevent/fdevent.h" #include "socket.h" #include "types.h" -#include "usb.h" constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024; constexpr size_t MAX_PAYLOAD = 1024 * 1024; @@ -139,7 +138,6 @@ int adb_server_main(int is_daemon, const std::string& socket_spec, int ack_reply /* initialize a transport object's func pointers and state */ int init_socket_transport(atransport* t, unique_fd s, int port, int local); -void init_usb_transport(atransport* t, usb_handle* usb); std::string getEmulatorSerialString(int console_port); #if ADB_HOST @@ -253,4 +251,5 @@ void update_transport_status(); // Wait until device scan has completed and every transport is ready, or a timeout elapses. void adb_wait_for_device_initialization(); +void usb_init(); #endif diff --git a/adb/client/main.cpp b/adb/client/main.cpp index 33e0716ab..4a9eadcb5 100644 --- a/adb/client/main.cpp +++ b/adb/client/main.cpp @@ -36,6 +36,7 @@ #include "adb_listeners.h" #include "adb_utils.h" #include "adb_wifi.h" +#include "client/usb.h" #include "commandline.h" #include "sysdeps/chrono.h" #include "transport.h" diff --git a/adb/transport_usb.cpp b/adb/client/transport_usb.cpp similarity index 97% rename from adb/transport_usb.cpp rename to adb/client/transport_usb.cpp index fb81b37e0..777edde0b 100644 --- a/adb/transport_usb.cpp +++ b/adb/client/transport_usb.cpp @@ -16,6 +16,10 @@ #define TRACE_TAG TRANSPORT +#include "sysdeps.h" + +#include "client/usb.h" + #include #include "sysdeps.h" @@ -135,8 +139,8 @@ static int remote_read(apacket* p, usb_handle* usb) { } p->payload.resize(p->msg.data_length); - if (usb_read(usb, &p->payload[0], p->payload.size()) - != static_cast(p->payload.size())) { + if (usb_read(usb, &p->payload[0], p->payload.size()) != + static_cast(p->payload.size())) { PLOG(ERROR) << "remote usb: terminated (data)"; return -1; } diff --git a/adb/usb.h b/adb/client/usb.h similarity index 72% rename from adb/usb.h rename to adb/client/usb.h index eb8ca6cc0..b371788cc 100644 --- a/adb/usb.h +++ b/adb/client/usb.h @@ -18,6 +18,9 @@ #include +#include "adb.h" +#include "transport.h" + // USB host/client interface. #define ADB_USB_INTERFACE(handle_ref_type) \ @@ -30,35 +33,38 @@ void usb_kick(handle_ref_type h); \ size_t usb_get_max_packet_size(handle_ref_type) -#if !ADB_HOST -// The daemon has a single implementation. - -struct usb_handle; -ADB_USB_INTERFACE(usb_handle*); - -#else // linux host || darwin // Linux and Darwin clients have native and libusb implementations. namespace libusb { - struct usb_handle; - ADB_USB_INTERFACE(libusb::usb_handle*); -} +struct usb_handle; +ADB_USB_INTERFACE(libusb::usb_handle*); +} // namespace libusb namespace native { - struct usb_handle; - ADB_USB_INTERFACE(native::usb_handle*); -} +struct usb_handle; +ADB_USB_INTERFACE(native::usb_handle*); +} // namespace native // Empty base that both implementations' opaque handles inherit from. -struct usb_handle { -}; +struct usb_handle {}; ADB_USB_INTERFACE(::usb_handle*); -#endif // linux host || darwin - - // USB device detection. int is_adb_interface(int usb_class, int usb_subclass, int usb_protocol); bool should_use_libusb(); + +struct UsbConnection : public BlockingConnection { + explicit UsbConnection(usb_handle* handle) : handle_(handle) {} + ~UsbConnection(); + + bool Read(apacket* packet) override final; + bool Write(apacket* packet) override final; + bool DoTlsHandshake(RSA* key, std::string* auth_key) override final; + + void Close() override final; + virtual void Reset() override final; + + usb_handle* handle_; +}; diff --git a/adb/client/usb_dispatch.cpp b/adb/client/usb_dispatch.cpp index f55ae9010..7b97117de 100644 --- a/adb/client/usb_dispatch.cpp +++ b/adb/client/usb_dispatch.cpp @@ -15,7 +15,8 @@ */ #include -#include "usb.h" + +#include "client/usb.h" void usb_init() { if (should_use_libusb()) { diff --git a/adb/client/usb_libusb.cpp b/adb/client/usb_libusb.cpp index 53f01a0ce..07cbc9418 100644 --- a/adb/client/usb_libusb.cpp +++ b/adb/client/usb_libusb.cpp @@ -14,10 +14,10 @@ * limitations under the License. */ -#include "usb.h" - #include "sysdeps.h" +#include "client/usb.h" + #include #include @@ -40,7 +40,6 @@ #include "adb.h" #include "adb_utils.h" #include "transport.h" -#include "usb.h" using android::base::StringPrintf; diff --git a/adb/client/usb_linux.cpp b/adb/client/usb_linux.cpp index 343e7b59a..95b1817dc 100644 --- a/adb/client/usb_linux.cpp +++ b/adb/client/usb_linux.cpp @@ -18,6 +18,8 @@ #include "sysdeps.h" +#include "client/usb.h" + #include #include #include @@ -48,7 +50,6 @@ #include "adb.h" #include "transport.h" -#include "usb.h" using namespace std::chrono_literals; using namespace std::literals; diff --git a/adb/client/usb_osx.cpp b/adb/client/usb_osx.cpp index 7207ca733..a93fa3a6b 100644 --- a/adb/client/usb_osx.cpp +++ b/adb/client/usb_osx.cpp @@ -18,6 +18,8 @@ #include "sysdeps.h" +#include "client/usb.h" + #include #include diff --git a/adb/client/usb_windows.cpp b/adb/client/usb_windows.cpp index 197c6fa5c..e209230c7 100644 --- a/adb/client/usb_windows.cpp +++ b/adb/client/usb_windows.cpp @@ -18,6 +18,8 @@ #include "sysdeps.h" +#include "client/usb.h" + // clang-format off #include // winsock.h *must* be included before windows.h. #include diff --git a/adb/daemon/usb.cpp b/adb/daemon/usb.cpp index 87937fb6a..7fff05af1 100644 --- a/adb/daemon/usb.cpp +++ b/adb/daemon/usb.cpp @@ -45,19 +45,15 @@ #include #include -#include - #include "adb_unique_fd.h" #include "adb_utils.h" +#include "daemon/usb_ffs.h" #include "sysdeps/chrono.h" #include "transport.h" #include "types.h" using android::base::StringPrintf; -// We can't find out whether we have support for AIO on ffs endpoints until we submit a read. -static std::optional gFfsAioSupported; - // Not all USB controllers support operations larger than 16k, so don't go above that. // Also, each submitted operation does an allocation in the kernel of that size, so we want to // minimize our queue depth while still maintaining a deep enough queue to keep the USB stack fed. @@ -612,17 +608,10 @@ struct UsbFfsConnection : public Connection { block->pending = true; struct iocb* iocb = &block->control; if (io_submit(aio_context_.get(), 1, &iocb) != 1) { - if (errno == EINVAL && !gFfsAioSupported.has_value()) { - HandleError("failed to submit first read, AIO on FFS not supported"); - gFfsAioSupported = false; - return false; - } - HandleError(StringPrintf("failed to submit read: %s", strerror(errno))); return false; } - gFfsAioSupported = true; return true; } @@ -741,17 +730,10 @@ struct UsbFfsConnection : public Connection { static constexpr int kInterruptionSignal = SIGUSR1; }; -void usb_init_legacy(); - static void usb_ffs_open_thread() { adb_thread_setname("usb ffs open"); while (true) { - if (gFfsAioSupported.has_value() && !gFfsAioSupported.value()) { - LOG(INFO) << "failed to use nonblocking ffs, falling back to legacy"; - return usb_init_legacy(); - } - unique_fd control; unique_fd bulk_out; unique_fd bulk_in; @@ -773,13 +755,5 @@ static void usb_ffs_open_thread() { } void usb_init() { - bool use_nonblocking = android::base::GetBoolProperty( - "persist.adb.nonblocking_ffs", - android::base::GetBoolProperty("ro.adb.nonblocking_ffs", true)); - - if (use_nonblocking) { - std::thread(usb_ffs_open_thread).detach(); - } else { - usb_init_legacy(); - } + std::thread(usb_ffs_open_thread).detach(); } diff --git a/adb/daemon/usb_ffs.cpp b/adb/daemon/usb_ffs.cpp index cb7e2fb88..7bd611b66 100644 --- a/adb/daemon/usb_ffs.cpp +++ b/adb/daemon/usb_ffs.cpp @@ -18,6 +18,8 @@ #include "sysdeps.h" +#include "daemon/usb_ffs.h" + #include #include @@ -26,7 +28,6 @@ #include #include "adb.h" -#include "adbd/usb.h" #define MAX_PACKET_SIZE_FS 64 #define MAX_PACKET_SIZE_HS 512 diff --git a/adb/daemon/usb_dummy.cpp b/adb/daemon/usb_ffs.h similarity index 52% rename from adb/daemon/usb_dummy.cpp rename to adb/daemon/usb_ffs.h index c9bf79731..a19d7ccce 100644 --- a/adb/daemon/usb_dummy.cpp +++ b/adb/daemon/usb_ffs.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2019 The Android Open Source Project + * Copyright (C) 2020 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. @@ -14,29 +14,9 @@ * limitations under the License. */ -#include +#pragma once -#include +#include -int usb_write(usb_handle*, const void*, int) { - LOG(FATAL) << "unimplemented"; - return -1; -} - -int usb_read(usb_handle*, void*, int) { - LOG(FATAL) << "unimplemented"; - return -1; -} - -int usb_close(usb_handle*) { - LOG(FATAL) << "unimplemented"; - return -1; -} - -void usb_reset(usb_handle*) { - LOG(FATAL) << "unimplemented"; -} - -void usb_kick(usb_handle*) { - LOG(FATAL) << "unimplemented"; -} +bool open_functionfs(android::base::unique_fd* control, android::base::unique_fd* bulk_out, + android::base::unique_fd* bulk_in); diff --git a/adb/transport.cpp b/adb/transport.cpp index 6dccb7f68..e06dbe327 100644 --- a/adb/transport.cpp +++ b/adb/transport.cpp @@ -1452,6 +1452,7 @@ void kick_all_tcp_devices() { #endif +#if ADB_HOST void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath, unsigned writeable) { atransport* t = new atransport(writeable ? kCsOffline : kCsNoPerm); @@ -1473,6 +1474,7 @@ void register_usb_transport(usb_handle* usb, const char* serial, const char* dev register_transport(t); } +#endif #if ADB_HOST // This should only be used for transports with connection_state == kCsNoPerm. diff --git a/adb/transport.h b/adb/transport.h index 3a77cf6d5..b1984db30 100644 --- a/adb/transport.h +++ b/adb/transport.h @@ -39,7 +39,6 @@ #include "adb.h" #include "adb_unique_fd.h" #include "types.h" -#include "usb.h" typedef std::unordered_set FeatureSet; @@ -204,20 +203,6 @@ struct FdConnection : public BlockingConnection { std::unique_ptr tls_; }; -struct UsbConnection : public BlockingConnection { - explicit UsbConnection(usb_handle* handle) : handle_(handle) {} - ~UsbConnection(); - - bool Read(apacket* packet) override final; - bool Write(apacket* packet) override final; - bool DoTlsHandshake(RSA* key, std::string* auth_key) override final; - - void Close() override final; - virtual void Reset() override final; - - usb_handle* handle_; -}; - // Waits for a transport's connection to be not pending. This is a separate // object so that the transport can be destroyed and another thread can be // notified of it in a race-free way. @@ -253,6 +238,10 @@ enum class ReconnectResult { Abort, }; +#if ADB_HOST +struct usb_handle; +#endif + class atransport : public enable_weak_from_this { public: // TODO(danalbert): We expose waaaaaaay too much stuff because this was @@ -293,8 +282,10 @@ class atransport : public enable_weak_from_this { return connection_; } +#if ADB_HOST void SetUsbHandle(usb_handle* h) { usb_handle_ = h; } usb_handle* GetUsbHandle() { return usb_handle_; } +#endif const TransportId id; @@ -401,8 +392,10 @@ class atransport : public enable_weak_from_this { // The underlying connection object. std::shared_ptr connection_ GUARDED_BY(mutex_); +#if ADB_HOST // USB handle for the connection, if available. usb_handle* usb_handle_ = nullptr; +#endif // A callback that will be invoked when the atransport needs to reconnect. ReconnectCallback reconnect_; @@ -443,8 +436,15 @@ void kick_all_transports_by_auth_key(std::string_view auth_key); #endif void register_transport(atransport* transport); -void register_usb_transport(usb_handle* h, const char* serial, - const char* devpath, unsigned writeable); + +#if ADB_HOST +void init_usb_transport(atransport* t, usb_handle* usb); +void register_usb_transport(usb_handle* h, const char* serial, const char* devpath, + unsigned writeable); + +// This should only be used for transports with connection_state == kCsNoPerm. +void unregister_usb_transport(usb_handle* usb); +#endif /* Connect to a network address and register it as a device */ void connect_device(const std::string& address, std::string* response); @@ -454,9 +454,6 @@ bool register_socket_transport(unique_fd s, std::string serial, int port, int lo atransport::ReconnectCallback reconnect, bool use_tls, int* error = nullptr); -// This should only be used for transports with connection_state == kCsNoPerm. -void unregister_usb_transport(usb_handle* usb); - bool check_header(apacket* p, atransport* t); void close_usb_devices(bool reset = false); diff --git a/fastboot/Android.bp b/fastboot/Android.bp index a757d56e5..884856dc7 100644 --- a/fastboot/Android.bp +++ b/fastboot/Android.bp @@ -115,6 +115,7 @@ cc_binary { "device/fastboot_device.cpp", "device/flashing.cpp", "device/main.cpp", + "device/usb.cpp", "device/usb_client.cpp", "device/utility.cpp", "device/variables.cpp", @@ -125,7 +126,6 @@ cc_binary { "android.hardware.boot@1.1", "android.hardware.fastboot@1.0", "android.hardware.health@2.0", - "libadbd", "libasyncio", "libbase", "libbootloader_message", diff --git a/adb/daemon/usb_legacy.cpp b/fastboot/device/usb.cpp similarity index 70% rename from adb/daemon/usb_legacy.cpp rename to fastboot/device/usb.cpp index fe80e7d59..4bee7b20c 100644 --- a/adb/daemon/usb_legacy.cpp +++ b/fastboot/device/usb.cpp @@ -14,9 +14,7 @@ * limitations under the License. */ -#define TRACE_TAG USB - -#include "sysdeps.h" +#include "usb.h" #include #include @@ -41,12 +39,9 @@ #include #include -#include "adb.h" -#include "adbd/usb.h" -#include "transport.h" - using namespace std::chrono_literals; +#define D(...) #define MAX_PACKET_SIZE_FS 64 #define MAX_PACKET_SIZE_HS 512 #define MAX_PACKET_SIZE_SS 1024 @@ -56,8 +51,6 @@ using namespace std::chrono_literals; // 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) -static unique_fd& dummy_fd = *new unique_fd(); - static void aio_block_init(aio_block* aiob, unsigned num_bufs) { aiob->iocb.resize(num_bufs); aiob->iocbs.resize(num_bufs); @@ -82,46 +75,6 @@ static int getMaxPacketSize(int ffs_fd) { } } -static bool init_functionfs(struct usb_handle* h) { - LOG(INFO) << "initializing functionfs"; - if (!open_functionfs(&h->control, &h->bulk_out, &h->bulk_in)) { - return false; - } - - h->read_aiob.fd = h->bulk_out.get(); - h->write_aiob.fd = h->bulk_in.get(); - h->reads_zero_packets = true; - return true; -} - -static void usb_legacy_ffs_open_thread(usb_handle* usb) { - adb_thread_setname("usb legacy ffs open"); - - while (true) { - // wait until the USB device needs opening - std::unique_lock lock(usb->lock); - while (!usb->open_new_connection) { - usb->notify.wait(lock); - } - usb->open_new_connection = false; - lock.unlock(); - - while (true) { - if (init_functionfs(usb)) { - LOG(INFO) << "functionfs successfully initialized"; - break; - } - std::this_thread::sleep_for(1s); - } - - LOG(INFO) << "registering usb transport"; - register_usb_transport(usb, nullptr, nullptr, 1); - } - - // never gets here - abort(); -} - static int usb_ffs_write(usb_handle* h, const void* data, int len) { D("about to write (fd=%d, len=%d)", h->bulk_in.get(), len); @@ -129,7 +82,7 @@ static int usb_ffs_write(usb_handle* h, const void* data, int len) { int orig_len = len; while (len > 0) { int write_len = std::min(USB_FFS_BULK_SIZE, len); - int n = adb_write(h->bulk_in, buf, write_len); + int n = write(h->bulk_in, buf, write_len); if (n < 0) { D("ERROR: fd = %d, n = %d: %s", h->bulk_in.get(), n, strerror(errno)); return -1; @@ -150,7 +103,7 @@ static int usb_ffs_read(usb_handle* h, void* data, int len, bool allow_partial) unsigned count = 0; while (len > 0) { int read_len = std::min(USB_FFS_BULK_SIZE, len); - int n = adb_read(h->bulk_out, buf, read_len); + int n = read(h->bulk_out, buf, read_len); if (n < 0) { D("ERROR: fd = %d, n = %d: %s", h->bulk_out.get(), n, strerror(errno)); return -1; @@ -232,7 +185,7 @@ static int usb_ffs_do_aio(usb_handle* h, const void* data, int len, bool read) { } } -static int usb_ffs_aio_read(usb_handle* h, void* data, int len, bool allow_partial) { +static int usb_ffs_aio_read(usb_handle* h, void* data, int len, bool /* allow_partial */) { return usb_ffs_do_aio(h, data, len, true); } @@ -240,32 +193,9 @@ static int usb_ffs_aio_write(usb_handle* h, const void* data, int len) { return usb_ffs_do_aio(h, data, len, false); } -static void usb_ffs_kick(usb_handle* h) { - int err; - - err = ioctl(h->bulk_in.get(), FUNCTIONFS_CLEAR_HALT); - if (err < 0) { - D("[ kick: source (fd=%d) clear halt failed (%d) ]", h->bulk_in.get(), errno); - } - - err = ioctl(h->bulk_out.get(), FUNCTIONFS_CLEAR_HALT); - if (err < 0) { - D("[ kick: sink (fd=%d) clear halt failed (%d) ]", h->bulk_out.get(), errno); - } - - // 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. - // Ditto the comment in usb_adb_kick. - h->kicked = true; - TEMP_FAILURE_RETRY(dup2(dummy_fd.get(), h->bulk_out.get())); - TEMP_FAILURE_RETRY(dup2(dummy_fd.get(), h->bulk_in.get())); -} - static void usb_ffs_close(usb_handle* h) { LOG(INFO) << "closing functionfs transport"; - h->kicked = false; h->bulk_out.reset(); h->bulk_in.reset(); @@ -291,37 +221,6 @@ usb_handle* create_usb_handle(unsigned num_bufs, unsigned io_size) { aio_block_init(&h->write_aiob, num_bufs); } h->io_size = io_size; - h->kick = usb_ffs_kick; h->close = usb_ffs_close; return h; } - -void usb_init_legacy() { - D("[ usb_init - using legacy FunctionFS ]"); - dummy_fd.reset(adb_open("/dev/null", O_WRONLY | O_CLOEXEC)); - CHECK_NE(-1, dummy_fd.get()); - - std::thread(usb_legacy_ffs_open_thread, create_usb_handle(USB_FFS_NUM_BUFS, USB_FFS_BULK_SIZE)) - .detach(); -} - -int usb_write(usb_handle* h, const void* data, int len) { - return h->write(h, data, len); -} - -int usb_read(usb_handle* h, void* data, int len) { - return h->read(h, data, len, false /* allow_partial */); -} - -int usb_close(usb_handle* h) { - h->close(h); - return 0; -} - -void usb_reset(usb_handle* h) { - usb_close(h); -} - -void usb_kick(usb_handle* h) { - h->kick(h); -} diff --git a/adb/daemon/include/adbd/usb.h b/fastboot/device/usb.h similarity index 84% rename from adb/daemon/include/adbd/usb.h rename to fastboot/device/usb.h index 2204246c1..6c3f54252 100644 --- a/adb/daemon/include/adbd/usb.h +++ b/fastboot/device/usb.h @@ -36,17 +36,14 @@ struct aio_block { }; struct usb_handle { - usb_handle() : kicked(false) { - } + usb_handle() {} std::condition_variable notify; std::mutex lock; - std::atomic kicked; bool open_new_connection = true; int (*write)(usb_handle* h, const void* data, int len); int (*read)(usb_handle* h, void* data, int len, bool allow_partial); - void (*kick)(usb_handle* h); void (*close)(usb_handle* h); // FunctionFS @@ -63,6 +60,4 @@ struct usb_handle { size_t io_size; }; -usb_handle *create_usb_handle(unsigned num_bufs, unsigned io_size); -bool open_functionfs(android::base::unique_fd* control, android::base::unique_fd* bulk_out, - android::base::unique_fd* bulk_in); +usb_handle* create_usb_handle(unsigned num_bufs, unsigned io_size); diff --git a/fastboot/device/usb_client.h b/fastboot/device/usb_client.h index e6a1a8b8c..e702a0d22 100644 --- a/fastboot/device/usb_client.h +++ b/fastboot/device/usb_client.h @@ -17,7 +17,7 @@ #include -#include +#include "usb.h" #include "transport.h"