system/dev/usb/usb-function-test/driver.cpp

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <assert.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <threads.h>

#include <ddk/binding.h>
#include <ddk/debug.h>
#include <ddk/device.h>
#include <ddk/driver.h>
#include <ddk/protocol/usb-function.h>
#include <usb/usb-request.h>
#include <zircon/listnode.h>
#include <zircon/process.h>
#include <zircon/syscalls.h>
#include <zircon/device/usb-function-test.h>
#include <zircon/device/usb-peripheral.h>

namespace usb_function_test {

#define BULK_TX_COUNT   16
#define BULK_RX_COUNT   16
#define INTR_COUNT      8

#define BULK_MAX_PACKET     512     // FIXME(voydanoff) USB 3.0 support
#define BULK_REQ_SIZE       4096    // FIXME(voydanoff) increase this when DCI drivers support
                                    //                  non-contiguous DMA buffers
#define INTR_REQ_SIZE       1024

typedef struct {
    zx_device_t* zxdev;
    usb_function_protocol_t function;

    list_node_t bulk_out_reqs;      // list of usb_request_t
    list_node_t bulk_in_reqs;       // list of usb_request_t
    list_node_t intr_reqs;          // list of usb_request_t

    uint8_t test_data[INTR_REQ_SIZE];
    size_t test_data_length;

    bool configured;
    usb_speed_t speed;

    mtx_t mutex;

    uint8_t bulk_out_addr;
    uint8_t bulk_in_addr;
    uint8_t intr_addr;
} usb_test_t;

 static struct {
    usb_interface_descriptor_t intf;
    usb_endpoint_descriptor_t intr_ep;
    usb_endpoint_descriptor_t bulk_out_ep;
    usb_endpoint_descriptor_t bulk_in_ep;
} descriptors = {
    .intf = {
        .bLength = sizeof(usb_interface_descriptor_t),
        .bDescriptorType = USB_DT_INTERFACE,
        .bInterfaceNumber = 0, // set later
        .bAlternateSetting = 0,
        .bNumEndpoints = 3,
        .bInterfaceClass = USB_CLASS_VENDOR,
        .bInterfaceSubClass = 0,
        .bInterfaceProtocol = 0,
        .iInterface = 0,
    },
    .intr_ep = {
        .bLength = sizeof(usb_endpoint_descriptor_t),
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = 0, // set later
        .bmAttributes = USB_ENDPOINT_INTERRUPT,
        .wMaxPacketSize = htole16(INTR_REQ_SIZE),
        .bInterval = 8,
    },
    .bulk_out_ep = {
        .bLength = sizeof(usb_endpoint_descriptor_t),
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = 0, // set later
        .bmAttributes = USB_ENDPOINT_BULK,
        .wMaxPacketSize = htole16(BULK_MAX_PACKET),
        .bInterval = 0,
    },
    .bulk_in_ep = {
        .bLength = sizeof(usb_endpoint_descriptor_t),
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = 0, // set later
        .bmAttributes = USB_ENDPOINT_BULK,
        .wMaxPacketSize = htole16(BULK_MAX_PACKET),
        .bInterval = 0,
    },
};

static void test_intr_complete(usb_request_t* req, void* cookie) {
    auto* test = static_cast<usb_test_t*>(cookie);

    zxlogf(LTRACE, "%s %d %ld\n", __func__, req->response.status, req->response.actual);

    mtx_lock(&test->mutex);
    list_add_tail(&test->intr_reqs, &req->node);
    mtx_unlock(&test->mutex);
}

static void test_bulk_out_complete(usb_request_t* req, void* cookie) {
    auto* test = static_cast<usb_test_t*>(cookie);

    zxlogf(LTRACE, "%s %d %ld\n", __func__, req->response.status, req->response.actual);

    if (req->response.status == ZX_ERR_IO_NOT_PRESENT) {
        mtx_lock(&test->mutex);
        list_add_head(&test->bulk_out_reqs, &req->node);
        mtx_unlock(&test->mutex);
        return;
    }
    if (req->response.status == ZX_OK) {
        mtx_lock(&test->mutex);
        usb_request_t* in_req = list_remove_head_type(&test->bulk_in_reqs, usb_request_t, node);
        mtx_unlock(&test->mutex);
        if (in_req) {
            // Send data back to host.
            void* buffer;
            usb_request_mmap(req, &buffer);
            usb_request_copy_to(in_req, buffer, req->response.actual, 0);
            req->header.length = req->response.actual;
            usb_function_queue(&test->function, in_req);
        } else {
            zxlogf(ERROR, "%s: no bulk in request available\n", __func__);
        }
    } else {
        zxlogf(ERROR, "%s: usb_read_complete called with status %d\n",
                __func__, req->response.status);
    }

    // Requeue read.
    usb_function_queue(&test->function, req);
}

static void test_bulk_in_complete(usb_request_t* req, void* cookie) {
    auto* test = static_cast<usb_test_t*>(cookie);

    zxlogf(LTRACE, "%s %d %ld\n", __func__, req->response.status, req->response.actual);

    mtx_lock(&test->mutex);
    list_add_tail(&test->bulk_in_reqs, &req->node);
    mtx_unlock(&test->mutex);
}

static const usb_descriptor_header_t* test_get_descriptors(void* ctx, size_t* out_length) {
    *out_length = sizeof(descriptors);
    return (const usb_descriptor_header_t *)&descriptors;
}

static zx_status_t test_control(void* ctx, const usb_setup_t* setup, void* buffer,
                                size_t buffer_length, size_t* out_actual) {
    auto* test = static_cast<usb_test_t*>(ctx);
    size_t length = le16toh(setup->wLength);
    if (length > buffer_length) {
        length = buffer_length;
    }
    *out_actual = 0;

    zxlogf(TRACE, "%s\n", __func__);
    if (setup->bmRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE) &&
        setup->bRequest == USB_FUNCTION_TEST_SET_DATA) {
        if (length > sizeof(test->test_data)) {
            length = sizeof(test->test_data);
        }
        memcpy(test->test_data, buffer, length);
        test->test_data_length = length;
        *out_actual = length;
        return ZX_OK;
    } else if (setup->bmRequestType == (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE) &&
        setup->bRequest == USB_FUNCTION_TEST_GET_DATA) {
        if (length > test->test_data_length) {
            length = test->test_data_length;
        }
        memcpy(buffer, test->test_data, length);
        *out_actual = length;
        return ZX_OK;
    } else if (setup->bmRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE) &&
        setup->bRequest == USB_FUNCTION_TEST_SEND_INTERUPT) {
        mtx_lock(&test->mutex);
        usb_request_t* req = list_remove_head_type(&test->intr_reqs, usb_request_t, node);
        mtx_unlock(&test->mutex);
        if (!req) {
            zxlogf(ERROR, "%s: no interrupt request available\n", __func__);
            // TODO(voydanoff) maybe stall in this case?
            return ZX_OK;
        }

        usb_request_copy_to(req, test->test_data, test->test_data_length, 0);
        req->header.length = test->test_data_length;
        usb_function_queue(&test->function, req);
        return ZX_OK;
    } else {
        return ZX_ERR_NOT_SUPPORTED;
    }
}

static zx_status_t test_set_configured(void* ctx, bool configured, usb_speed_t speed) {
    zxlogf(TRACE, "%s: %d %d\n", __func__, configured, speed);
    auto* test = static_cast<usb_test_t*>(ctx);
    zx_status_t status;

    if (configured) {
        if ((status = usb_function_config_ep(&test->function, &descriptors.intr_ep, NULL))
                != ZX_OK ||
            (status = usb_function_config_ep(&test->function, &descriptors.bulk_out_ep, NULL))
                != ZX_OK ||
            (status = usb_function_config_ep(&test->function, &descriptors.bulk_in_ep, NULL))
                != ZX_OK) {
            zxlogf(ERROR, "%s: usb_function_config_ep failed\n", __func__);
            return status;
        }
        test->speed = speed;
    } else {
        usb_function_disable_ep(&test->function, test->bulk_out_addr);
        usb_function_disable_ep(&test->function, test->bulk_in_addr);
        usb_function_disable_ep(&test->function, test->intr_addr);
        test->speed = USB_SPEED_UNDEFINED;
    }
    test->configured = configured;

    if (configured) {
        // Queue our OUT requests.
        usb_request_t* req;
        while ((req = list_remove_head_type(&test->bulk_out_reqs, usb_request_t, node)) != NULL) {
            usb_function_queue(&test->function, req);
        }
    }

    return ZX_OK;
}

static zx_status_t test_set_interface(void* ctx, unsigned interface, unsigned alt_setting) {
    return ZX_ERR_NOT_SUPPORTED;
}

usb_function_interface_ops_t device_ops = {
    .get_descriptors = test_get_descriptors,
    .control = test_control,
    .set_configured = test_set_configured,
    .set_interface = test_set_interface,
};

static void usb_test_unbind(void* ctx) {
    zxlogf(TRACE, "%s\n", __func__);
    auto* test = static_cast<usb_test_t*>(ctx);

    device_remove(test->zxdev);
}

static void usb_test_release(void* ctx) {
    zxlogf(TRACE, "%s\n", __func__);
    auto* test = static_cast<usb_test_t*>(ctx);
    usb_request_t* req;

    while ((req = list_remove_head_type(&test->bulk_out_reqs, usb_request_t, node)) != NULL) {
        usb_request_release(req);
    }
    while ((req = list_remove_head_type(&test->bulk_in_reqs, usb_request_t, node)) != NULL) {
        usb_request_release(req);
    }
    while ((req = list_remove_head_type(&test->intr_reqs, usb_request_t, node)) != NULL) {
        usb_request_release(req);
    }
    mtx_destroy(&test->mutex);
    free(test);
}

static zx_protocol_device_t usb_test_proto = [](){
    zx_protocol_device_t dev;
    dev.version = DEVICE_OPS_VERSION;
    dev.unbind = usb_test_unbind;
    dev.release = usb_test_release;
    return dev;
}();

zx_status_t usb_test_bind(void* ctx, zx_device_t* parent) {
    zxlogf(INFO, "%s\n", __func__);

    auto* test = static_cast<usb_test_t*>(calloc(1, sizeof(usb_test_t)));
    if (!test) {
        return ZX_ERR_NO_MEMORY;
    }

    zx_status_t status = device_get_protocol(parent, ZX_PROTOCOL_USB_FUNCTION, &test->function);
    if (status != ZX_OK) {
        free(test);
        return status;
    }

    list_initialize(&test->bulk_out_reqs);
    list_initialize(&test->bulk_in_reqs);
    list_initialize(&test->intr_reqs);
    mtx_init(&test->mutex, mtx_plain);

    usb_function_interface_t intf = {};
    intf.ops = &device_ops;
    intf.ctx = test;

    status = usb_function_alloc_interface(&test->function, &descriptors.intf.bInterfaceNumber);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s: usb_function_alloc_interface failed\n", __func__);
        goto fail;
    }

    status = usb_function_alloc_ep(&test->function, USB_DIR_OUT, &test->bulk_out_addr);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s: usb_function_alloc_ep failed\n", __func__);
        goto fail;
    }
    status = usb_function_alloc_ep(&test->function, USB_DIR_IN, &test->bulk_in_addr);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s: usb_function_alloc_ep failed\n", __func__);
        goto fail;
    }
    status = usb_function_alloc_ep(&test->function, USB_DIR_IN, &test->intr_addr);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s: usb_function_alloc_ep failed\n", __func__);
        goto fail;
    }

    descriptors.bulk_out_ep.bEndpointAddress = test->bulk_out_addr;
    descriptors.bulk_in_ep.bEndpointAddress = test->bulk_in_addr;
    descriptors.intr_ep.bEndpointAddress = test->intr_addr;

    // allocate bulk out usb requests
    usb_request_t* req;
    for (int i = 0; i < BULK_TX_COUNT; i++) {
        status = usb_request_alloc(&req, BULK_REQ_SIZE, test->bulk_out_addr, sizeof(usb_request_t));
        if (status != ZX_OK) {
            goto fail;
        }
        req->complete_cb = test_bulk_out_complete;
        req->cookie = test;
        list_add_head(&test->bulk_out_reqs, &req->node);
    }
    // allocate bulk in usb requests
    for (int i = 0; i < BULK_RX_COUNT; i++) {
        status = usb_request_alloc(&req, BULK_REQ_SIZE, test->bulk_in_addr, sizeof(usb_request_t));
        if (status != ZX_OK) {
            goto fail;
        }

        req->complete_cb = test_bulk_in_complete;
        req->cookie = test;
        list_add_head(&test->bulk_in_reqs, &req->node);
    }

    // allocate interrupt requests
    for (int i = 0; i < INTR_COUNT; i++) {
        status = usb_request_alloc(&req, INTR_REQ_SIZE, test->intr_addr, sizeof(usb_request_t));
        if (status != ZX_OK) {
            goto fail;
        }

        req->complete_cb = test_intr_complete;
        req->cookie = test;
        list_add_head(&test->intr_reqs, &req->node);
    }
{
    device_add_args_t args = {};
    args.version = DEVICE_ADD_ARGS_VERSION;
    args.name = "usb-function-test";
    args.ctx = test;
    args.ops = &usb_test_proto;
    args.flags = DEVICE_ADD_NON_BINDABLE;

    status = device_add(parent, &args, &test->zxdev);
    if (status != ZX_OK) {
        zxlogf(ERROR, "%s: add_device failed %d\n", __func__, status);
        goto fail;
    }
}
    usb_function_register(&test->function, &intf);

    return ZX_OK;

fail:
    usb_test_release(test);
    return status;
}

static zx_driver_ops_t driver_ops = [](){
    zx_driver_ops_t ops;
    ops.version = DRIVER_OPS_VERSION;
    ops.bind = usb_test_bind;
    return ops;
}();

} // namespace usb_function_test

// clang-format off
ZIRCON_DRIVER_BEGIN(usb_function_test, usb_function_test::driver_ops, "zircon", "0.1", 3)
    BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_USB_FUNCTION),
    BI_ABORT_IF(NE, BIND_USB_VID, GOOGLE_USB_VID),
    BI_MATCH_IF(EQ, BIND_USB_PID, GOOGLE_USB_FUNCTION_TEST_PID),
ZIRCON_DRIVER_END(usb_function_test)