src/devtools/adb/usb_linux_client.c

/*
 * Copyright (C) 2007 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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <linux/usb/ch9.h>
#include <linux/usb/functionfs.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <stddef.h>
#include <sys/epoll.h>

#include "sysdeps.h"

#define   TRACE_TAG  TRACE_USB
#include "adb.h"

#define MAX_PACKET_SIZE_FS	64
#define MAX_PACKET_SIZE_HS	512
#define MAX_PACKET_SIZE_SS	1024

//#define cpu_to_le16(x)  htole16(x)
//#define cpu_to_le32(x)  htole32(x)
/*
 * cpu_to_le16/32 are used when initializing structures, a context where a
 * function call is not allowed. To solve this, we code cpu_to_le16/32 in a way
 * that allows them to be used when initializing structures.
 */

#if __BYTE_ORDER == __LITTLE_ENDIAN
#define cpu_to_le16(x)  (x)
#define cpu_to_le32(x)  (x)
#else
#define cpu_to_le16(x)  ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))
#define cpu_to_le32(x)  \
    ((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >>  8) | \
    (((x) & 0x0000ff00u) <<  8) | (((x) & 0x000000ffu) << 24))
#endif

#define FFS_CONTOL_MAX_EPOLL_EVENT 50
#define DEBUG   0

#define USB_FFS_WAKE_LOCK_ID           "usb_adbd_wakelock"
#define USB_FFS_WAKE_LOCK_TIMEOUT      (2 * 1000)

static const char* sTag = "adbd_usb";
adb_mutex_t g_wake_lock;
timer_t g_wake_unlock_timer;
bool g_wake_lock_acquired;
typedef void (*timer_routine) (int id);

struct usb_handle
{
    adb_cond_t notify;
    adb_mutex_t lock;

    int (*write)(usb_handle *h, const void *data, int len);
    int (*read)(usb_handle *h, void *data, int len);
    void (*kick)(usb_handle *h);

    // Legacy f_adb
    int fd;

    // FunctionFS
    int control;
    int bulk_out; /* "out" from the host's perspective => source for adbd */
    int bulk_in;  /* "in" from the host's perspective => sink for adbd */
    bool ffs_control_thread_created;
    bool ffs_control_suspend_mode;
};

static const struct {
    __le32 magic;
    __le32 length;
    __le32 flags;
    __le32 fs_count;
    __le32 hs_count;
    __le32 ss_count;
    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;
    struct {
        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)) ss_descs;
} __attribute__((packed)) descriptors = {
    .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
    .length = cpu_to_le32(sizeof(descriptors)),
    .flags = cpu_to_le32(FUNCTIONFS_HAS_FS_DESC |
                         FUNCTIONFS_HAS_HS_DESC |
                         FUNCTIONFS_HAS_SS_DESC),
    .fs_count = 3,
    .hs_count = 3,
    .ss_count = 5,
    .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,
        },
    },
    .ss_descs = {
        .intf = {
            .bLength = sizeof(descriptors.ss_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.ss_descs.source),
            .bDescriptorType = USB_DT_ENDPOINT,
            .bEndpointAddress = 1 | USB_DIR_OUT,
            .bmAttributes = USB_ENDPOINT_XFER_BULK,
            .wMaxPacketSize = MAX_PACKET_SIZE_SS,
        },
        .source_comp = {
            .bLength = sizeof(descriptors.ss_descs.source_comp),
            .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
        },
        .sink = {
            .bLength = sizeof(descriptors.ss_descs.sink),
            .bDescriptorType = USB_DT_ENDPOINT,
            .bEndpointAddress = 2 | USB_DIR_IN,
            .bmAttributes = USB_ENDPOINT_XFER_BULK,
            .wMaxPacketSize = MAX_PACKET_SIZE_SS,
        },
        .sink_comp = {
            .bLength = sizeof(descriptors.ss_descs.sink_comp),
            .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
        },
    },
};

#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_,
    },
};

static void *usb_adb_open_thread(void *x)
{
    struct usb_handle *usb = (struct usb_handle *)x;
    int fd;

    while (1) {
        // wait until the USB device needs opening
        adb_mutex_lock(&usb->lock);
        while (usb->fd != -1)
            adb_cond_wait(&usb->notify, &usb->lock);
        adb_mutex_unlock(&usb->lock);

        D("[ usb_thread - opening device ]\n");
        do {
            /* XXX use inotify? */
            fd = unix_open("/dev/android_adb", O_RDWR);
            if (fd < 0) {
                // to support older kernels
                fd = unix_open("/dev/android", O_RDWR);
            }
            if (fd < 0) {
                adb_sleep_ms(1000);
            }
        } while (fd < 0);
        D("[ opening device succeeded ]\n");

        close_on_exec(fd);
        usb->fd = fd;

        D("[ usb_thread - registering device ]\n");
        register_usb_transport(usb, 0, 0, 1);
    }

    // never gets here
    return 0;
}

static int usb_adb_write(usb_handle *h, const void *data, int len)
{
    int n;

    D("about to write (fd=%d, len=%d)\n", h->fd, len);
    n = adb_write(h->fd, data, len);
    if(n != len) {
        D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
            h->fd, n, errno, strerror(errno));
        return -1;
    }
    D("[ done fd=%d ]\n", h->fd);
    return 0;
}

static int usb_adb_read(usb_handle *h, void *data, int len)
{
    int n;

    D("about to read (fd=%d, len=%d)\n", h->fd, len);
    n = adb_read(h->fd, data, len);
    if(n != len) {
        D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
            h->fd, n, errno, strerror(errno));
        return -1;
    }
    D("[ done fd=%d ]\n", h->fd);
    return 0;
}

static void usb_adb_kick(usb_handle *h)
{
    D("usb_kick\n");
    adb_mutex_lock(&h->lock);
    adb_close(h->fd);
    h->fd = -1;

    // notify usb_adb_open_thread that we are disconnected
    adb_cond_signal(&h->notify);
    adb_mutex_unlock(&h->lock);
}

static void usb_adb_init()
{
    usb_handle *h;
    adb_thread_t tid;
    int fd;

    h = calloc(1, sizeof(usb_handle));
    if (h == 0) {
        fatal("cannot allocate usb_handle");
        return;
    }

    h->write = usb_adb_write;
    h->read = usb_adb_read;
    h->kick = usb_adb_kick;
    h->bulk_in = -1;
    h->bulk_out = -1;
    h->control = -1;
    h->ffs_control_thread_created = false;
    h->ffs_control_suspend_mode = false;
    h->fd = -1;

    adb_cond_init(&h->notify, 0);
    adb_mutex_init(&h->lock, 0);
    adb_mutex_init(&g_wake_lock, 0);

    // Open the file /dev/android_adb_enable to trigger
    // the enabling of the adb USB function in the kernel.
    // We never touch this file again - just leave it open
    // indefinitely so the kernel will know when we are running
    // and when we are not.
    fd = unix_open("/dev/android_adb_enable", O_RDWR);
    if (fd < 0) {
       D("failed to open /dev/android_adb_enable\n");
    } else {
        close_on_exec(fd);
    }

    D("[ usb_init - starting thread ]\n");
    if(adb_thread_create(&tid, usb_adb_open_thread, h)){
        fatal_errno("cannot create usb thread");
    }
}

////////////////////// wake lock ///////////////////////////////
timer_t timer_init(timer_routine cb, int id) {
    struct sigevent sevp;
    timer_t timerid;

    memset(&sevp, 0, sizeof(sevp));
    sevp.sigev_value.sival_int = id;
    sevp.sigev_notify = SIGEV_THREAD;
    sevp.sigev_notify_function = (void*)cb;

    if(timer_create(CLOCK_BOOTTIME, &sevp, &timerid) == -1) {
       D("timer_init() timer_create() failed, reason=[%s]%d",
            strerror(errno), errno);
        return NULL;
    }
    return timerid;
}

bool timer_start(timer_t timerid, int milliseconds) {
    struct itimerspec expire;
    expire.it_interval.tv_sec = 0;
    expire.it_interval.tv_nsec = 0;
    expire.it_value.tv_sec = milliseconds/1000;
    expire.it_value.tv_nsec = (milliseconds%1000)*1000000;
    if(timer_settime(timerid, 0, &expire, NULL) == -1) {
        D("timer_start() timer_settime() failed, reason=[%s]%d", strerror(errno), errno);
        return false;
    }
    return true;
}

bool timer_stop(timer_t timerid) {
    return timer_start(timerid, 0);
}

bool usb_ffs_wake_lock() {
#if !defined(__LBS_OS_LINUX__)    //no permission to open wake_lock on Linux
    int fd = adb_open("/sys/power/wake_lock", O_RDWR | O_NONBLOCK);
    if(fd == -1) {
        D("[%s] open() failed, reason=[%s]%d", sTag, strerror(errno), errno);
        return false;
    }

    int ret = adb_write(fd, USB_FFS_WAKE_LOCK_ID, strlen(USB_FFS_WAKE_LOCK_ID));
    if(ret == -1) {
        D("[%s] write() failed id=[%s], reason=[%s]%d", sTag, USB_FFS_WAKE_LOCK_ID, strerror(errno), errno);
        adb_close(fd);
        return false;
    }

    adb_close(fd);
#endif
    return true;
}

bool usb_ffs_wake_unlock() {
#if !defined(__LBS_OS_LINUX__)    //no permission to open wake_lock on Linux
    int fd = adb_open("/sys/power/wake_unlock", O_RDWR | O_NONBLOCK);
    if(fd == -1) {
        D("[%s] open() failed, reason=[%s]%d", sTag, strerror(errno), errno);
        return false;
    }

    int ret = adb_write(fd, USB_FFS_WAKE_LOCK_ID, strlen(USB_FFS_WAKE_LOCK_ID));
    if(ret == -1) {
        D("[%s] write() failed id=[%s], reason=[%s]%d", sTag,
                USB_FFS_WAKE_LOCK_ID, strerror(errno), errno);
        adb_close(fd);
        return false;
    }

    adb_close(fd);
#endif
    return true;
}

static void usb_ffs_timer_wake_unlock_routine(int id) {
    //do not use the internal msg or it will cause infinite loop in epoll_wait
    adb_mutex_lock(&g_wake_lock);
    if(g_wake_lock_acquired) {
        if(usb_ffs_wake_unlock()) {
            g_wake_lock_acquired = false;
        }
    }
    if (DEBUG) D("[%s] unlock wake_lock_acquired=[%d]", sTag, g_wake_lock_acquired);
    adb_mutex_unlock(&g_wake_lock);
}

static void *ffs_control_read_msg_thread(void *_h)
{
    usb_handle *h = _h;
    int fd = h->control;

    char buf[MAX_PACKET_SIZE_FS];
    int size = 0;//event.u.setup.wLength;
    if (DEBUG) D("FUNCTIONFS_SETUP acking host-to-device control transfer size=%d", size);
    if (size+1 > MAX_PACKET_SIZE_FS) {
        D("package size larger than MAX_PACKET_SIZE_FS");
        return 0;
    }

    if (DEBUG) D("FUNCTIONFS_SETUP before get host-to-device msg size:%d", size);
    int rc = adb_read(fd, buf, size);
    if (DEBUG) D("FUNCTIONFS_SETUP after get host-to-device msg rc:%d", rc);
    if (rc != size) {
        D("Read %d bytes when trying to read control request, expected %d", rc, size);
    }
    return 0;
}

static char* ffs_get_event_type_code(int type) {
    char* code;
    switch(type) {
        case FUNCTIONFS_BIND:
            code = "BIND";
            break;
        case FUNCTIONFS_UNBIND:
            code = "UNBIND";
            break;
        case FUNCTIONFS_ENABLE:
            code = "ENABLE";
            break;
        case FUNCTIONFS_DISABLE:
            code = "DISABLE";
            break;
        case FUNCTIONFS_SETUP:
            code = "SETUP";
            break;
        case FUNCTIONFS_SUSPEND:
            code = "SUSPEND";
            break;
        case FUNCTIONFS_RESUME:
            code = "RESUME";
            break;
        default:
            code = "UNKNOWN";
            break;
        }
    return code;
}

static void ffs_control_event_handler(usb_handle *h) {
    int fd = h->control;
    struct usb_functionfs_event event;
    int ret = 0;

    if (DEBUG) D("start remote usb read control fd:%d size=%d\n", fd, (int)sizeof(event));
    ret = adb_read(fd, &event, sizeof(event));
    if (DEBUG) D("done remote usb read control ret=%d size=%d\n", ret, (int)sizeof(event));
    if (ret != sizeof(event)) {
        if (DEBUG) D("remote usb: read size:%d not expect to event size:%d\n", ret, (int)sizeof(event));
        return;
    }

    D("event.type: %s\n", ffs_get_event_type_code(event.type));

    switch (event.type) {
        case FUNCTIONFS_SUSPEND:
            D("received FUNCTIONFS_SUSPEND set suspend mode 1");
            h->ffs_control_suspend_mode = true;
            break;
        case FUNCTIONFS_RESUME:
            D("received FUNCTIONFS_RESUME");
            break;
        case FUNCTIONFS_SETUP: {
            D("received FUNCTIONFS_SETUP");
            D("bRequestType = %d",(int)(event.u.setup.bRequestType));
            D("bRequest = %d\n", (int)(event.u.setup.bRequest));
            D("wValue = %d\n", (int)(event.u.setup.wValue));
            D("wIndex = %d\n", (int)(event.u.setup.wIndex));
            D("wLength = %d\n", (int)(event.u.setup.wLength));

            if ((event.u.setup.bRequestType & USB_DIR_IN)) {
                if (DEBUG) D("FUNCTIONFS_SETUP acking device-to-host control transfer");
                int rc = adb_write(fd, "", 0);
                if (rc != 0) {
                    D("Failed to write empty packet to host");
                    break;
                }
            } else {
                adb_thread_t ffs_control_read_msg_thread_ptr;

                if(adb_thread_create(&ffs_control_read_msg_thread_ptr, ffs_control_read_msg_thread, h)) {
                    fatal_errno("cannot create control thread");
                }


                if (DEBUG) D("Wait 100ms before kill read msg thread");
                adb_sleep_ms(100);
                int ret = pthread_cancel(ffs_control_read_msg_thread_ptr);
                D("Done kill the read msg thread ret=%d", ret);
            }
        }
    }
}

// -1 means failure
static int epoll_add_fd(int epfd, int fd) {
    struct epoll_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.data.fd = fd;
    ev.events = EPOLLIN;
    // don't set the fd to edge trigger
    // the some event like accept may be lost if two or more clients are connecting to server at the same time
    // level trigger is preferred to avoid event lost
    // do not set EPOLLOUT due to it will always trigger when write is available
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        D("epoll_add_fd3() epoll_ctl() failed reason=[%s]%d epfd=%d fd=%d",
            strerror(errno), errno, epfd, fd);
        return -1;
    }
    return 0;
}

static void *ffs_control_thread(void *_h)
{
    usb_handle *h = _h;
    int control_fd = h->control;
    struct epoll_event events[FFS_CONTOL_MAX_EPOLL_EVENT];

    g_wake_unlock_timer = timer_init(usb_ffs_timer_wake_unlock_routine, 0);
    int epfd = epoll_create(FFS_CONTOL_MAX_EPOLL_EVENT);
    if(epfd == -1) {
        D("ERR: epoll_create() fail reason=[%s]", strerror(errno));
        return 0;
    }

    epoll_add_fd(epfd, control_fd);

    while(1) {
        int i;
        int n;

        D("Before ffs control thread epoll_wait");
        n = epoll_wait(epfd, events, FFS_CONTOL_MAX_EPOLL_EVENT , -1);

        adb_mutex_lock(&g_wake_lock);
        timer_stop(g_wake_unlock_timer);
        if (!g_wake_lock_acquired) {
            g_wake_lock_acquired = usb_ffs_wake_lock();
            if (DEBUG) D("[%s] wake_lock_acquired=[%d]", sTag, g_wake_lock_acquired);
        }
        adb_mutex_unlock(&g_wake_lock);

        for(i = 0; i < n; i++) {
            if(events[i].data.fd == control_fd) {
                if(events[i].events & EPOLLIN) {
                    if (DEBUG) D("control_fd event triggered");
                    ffs_control_event_handler(h);
                }
            }
        }

        timer_start(g_wake_unlock_timer, USB_FFS_WAKE_LOCK_TIMEOUT);
    }
}

void ffs_create_control_thread(usb_handle *h) {
    if (h->control >= 0) {  // only for ffs usb
        if (!h->ffs_control_thread_created) {
            adb_thread_t ffs_control_thread_ptr;

            if(adb_thread_create(&ffs_control_thread_ptr, ffs_control_thread, h)){
                fatal_errno("cannot create ffs_control_thread");
            } else {
                h->ffs_control_thread_created = true;
                if (DEBUG) D("Created ffs_control_thread success");
            }
        }
    }
}

static void init_functionfs(struct usb_handle *h)
{
    ssize_t ret;

    if (h->control < 0) { // might have already done this before
        D("OPENING %s\n", 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));
        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;
        }
    }

    h->bulk_out = adb_open(USB_FFS_ADB_OUT, O_RDWR);
    if (h->bulk_out < 0) {
        D("[ %s: cannot open bulk-out ep: errno=%d ]\n", USB_FFS_ADB_OUT, errno);
        goto err;
    }

    h->bulk_in = adb_open(USB_FFS_ADB_IN, O_RDWR);
    if (h->bulk_in < 0) {
        D("[ %s: cannot open bulk-in ep: errno=%d ]\n", USB_FFS_ADB_IN, errno);
        goto err;
    }

    ffs_create_control_thread(h);
    return;

err:
    if (h->bulk_in > 0) {
        adb_close(h->bulk_in);
        h->bulk_in = -1;
    }
    if (h->bulk_out > 0) {
        adb_close(h->bulk_out);
        h->bulk_out = -1;
    }
    if (h->control > 0) {
        adb_close(h->control);
        h->control = -1;
    }
    return;
}

static void *usb_ffs_open_thread(void *x)
{
    struct usb_handle *usb = (struct usb_handle *)x;

    while (1) {
        // wait until the USB device needs opening
        adb_mutex_lock(&usb->lock);
        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 && usb->bulk_in >= 0 && usb->bulk_out >= 0)
                break;

            adb_sleep_ms(1000);
        }

        D("[ usb_thread - registering device ]\n");
        register_usb_transport(usb, 0, 0, 1);
    }

    // never gets here
    return 0;
}

static int bulk_write(int bulk_in, const char *buf, size_t length)
{
    size_t count = 0;
    int ret;

    do {
        ret = adb_write(bulk_in, buf + count, length - count);
        if (ret < 0) {
            if (errno != EINTR)
                return ret;
        } else {
            count += ret;
        }
    } while (count < length);

    D("[ bulk_write done fd=%d ]\n", bulk_in);
    return count;
}

static int usb_ffs_write(usb_handle *h, const void *data, int len)
{
    int n;

    D("about to write (fd=%d, len=%d)\n", h->bulk_in, len);
    n = bulk_write(h->bulk_in, data, len);
    if (n != len) {
        D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
            h->bulk_in, n, errno, strerror(errno));
        return -1;
    }
    D("[ done fd=%d ]\n", h->bulk_in);
    return 0;
}

static int bulk_read(int bulk_out, char *buf, size_t length)
{
    size_t count = 0;
    int ret;

    do {
        ret = adb_read(bulk_out, buf + count, length - count);
        if (ret < 0) {
            if (errno != EINTR) {
                D("[ bulk_read failed fd=%d length=%zu count=%zu ]\n",
                                           bulk_out, length, count);
                return ret;
            }
        } else {
            count += ret;
        }
    } while (count < length);

    return count;
}

static int usb_ffs_read(usb_handle *h, void *data, int len)
{
    int n;

    D("about to read (fd=%d, len=%d)\n", h->bulk_out, len);
    n = bulk_read(h->bulk_out, data, len);
    if (h->ffs_control_suspend_mode) {
        if (n < 0) {
            int ret_err  = -1 * errno;
            D("Suspended bulk_read() ERROR: fd = %d, n = %d, errno = %d (%s) ret_err=%d\n",
                h->bulk_out, n, errno, strerror(errno), ret_err);
            return ret_err;
        } else {
            D("Suspended bulk_read: fd = %d, n = %d, errno = %d (%s) len:%d data:%s\n",
                h->bulk_out, n, errno, strerror(errno), len, data);
        }
    } else if (n != len) {
        D("ERROR: fd = %d, n = %d, errno = %d (%s)\n",
            h->bulk_out, n, errno, strerror(errno));
        return -1;
    }
    h->ffs_control_suspend_mode = false;
    D("[ done fd=%d ]\n", h->bulk_out);
    return 0;
}

static void usb_ffs_kick(usb_handle *h)
{
    int err;

    err = ioctl(h->bulk_in, FUNCTIONFS_CLEAR_HALT);
    if (err < 0)
        D("[ kick: source (fd=%d) clear halt failed (%d) ]", h->bulk_in, errno);

    err = ioctl(h->bulk_out, FUNCTIONFS_CLEAR_HALT);
    if (err < 0)
        D("[ kick: sink (fd=%d) clear halt failed (%d) ]", h->bulk_out, errno);

    adb_mutex_lock(&h->lock);

    // 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->bulk_out = h->bulk_in = -1;

    // notify usb_ffs_open_thread that we are disconnected
    adb_cond_signal(&h->notify);
    adb_mutex_unlock(&h->lock);
}

static void usb_ffs_init()
{
    usb_handle *h;
    adb_thread_t tid;

    D("[ usb_init - using FunctionFS ]\n");

    h = calloc(1, sizeof(usb_handle));
    if (h == 0) {
        fatal("cannot allocate usb_handle");
        return;
    }

    h->write = usb_ffs_write;
    h->read = usb_ffs_read;
    h->kick = usb_ffs_kick;

    h->control  = -1;
    h->bulk_out = -1;
    h->bulk_out = -1;
    h->ffs_control_thread_created = false;

    adb_cond_init(&h->notify, 0);
    adb_mutex_init(&h->lock, 0);
    adb_mutex_init(&g_wake_lock, 0);

    D("[ usb_init - starting thread ]\n");
    if (adb_thread_create(&tid, usb_ffs_open_thread, h)){
        fatal_errno("[ cannot create usb thread ]\n");
    }
}

void usb_init()
{
    if (access(USB_FFS_ADB_EP0, F_OK) == 0)
        usb_ffs_init();
    else
        usb_adb_init();
}

void usb_cleanup()
{
}

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);
}
int usb_close(usb_handle *h)
{
    return 0;
}

void usb_kick(usb_handle *h)
{
    h->kick(h);
}