system/dev/usb/usb-peripheral-test/test.cpp - zircon/ - Git at Google

 // 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 <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <thread>

 #include <fbl/auto_call.h>
 #include <usbhost/usbhost.h>
 #include <unittest/unittest.h>
 #include <zircon/device/usb-peripheral-test.h>
 #include <zircon/device/usb-peripheral.h>

 namespace {

 struct usb_device* dev = nullptr;
 struct usb_endpoint_descriptor* bulk_out_ep = nullptr;
 struct usb_endpoint_descriptor* bulk_in_ep = nullptr;
 struct usb_endpoint_descriptor* intr_ep = nullptr;

 constexpr size_t BUFFER_SIZE = 4096;

 // Data to send to the device
 uint8_t send_buf[BUFFER_SIZE] = {};
 // Buffer for receiving data from the device
 int receive_buf[BUFFER_SIZE] = {};

 constexpr int TIMEOUT = 1000; // 1 seecond


 // Fill send_buf with random values.
 void randomize() {
     // Generate some random data.
     for (size_t i = 0; i < sizeof(send_buf); i++) {
         send_buf[i] = static_cast<uint8_t>(random());
     }
 }

 // Tests control and interrupt transfers with specified transfer size.
 bool control_interrupt_test(size_t transfer_size) {
     BEGIN_TEST;

     randomize();

     // Send data to device via OUT control request.
     int ret = usb_device_control_transfer(dev,
                             USB_DIR_OUT | USB_TYPE_VENDOR | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                             USB_PERIPHERAL_TEST_SET_DATA, 0, 0, send_buf, transfer_size, TIMEOUT);
     EXPECT_EQ(ret, transfer_size);

     // Receive data back from device via IN control request.
     ret = usb_device_control_transfer(dev,
                             USB_DIR_IN | USB_TYPE_VENDOR | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                             USB_PERIPHERAL_TEST_GET_DATA, 0, 0, receive_buf, transfer_size,
                             TIMEOUT);
     EXPECT_EQ(ret, transfer_size);

     // Sent and received data should match.
     EXPECT_EQ(memcmp(send_buf, receive_buf, transfer_size), 0);

     // Create a thread to wait for interrupt request.
     auto thread_func = [](struct usb_request** req) -> void {
         *req = usb_request_wait(dev, TIMEOUT);
     };
     struct usb_request* complete_req = nullptr;
     std::thread wait_thread (thread_func, &complete_req);

     // Queue read for interrupt request
     auto* req = usb_request_new(dev, intr_ep);
     EXPECT_NE(req, nullptr);
     req->buffer = receive_buf;
     req->buffer_length = static_cast<int>(transfer_size);
     ret = usb_request_queue(req);
     EXPECT_EQ(ret, 0);

     // Ask the device to send us an interrupt request containing the data we sent earlier.
     ret = usb_device_control_transfer(dev,
                             USB_DIR_OUT | USB_TYPE_VENDOR | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
                             USB_PERIPHERAL_TEST_SEND_INTERUPT, 0, 0, nullptr, 0, TIMEOUT);
     EXPECT_EQ(ret, 0);

     wait_thread.join();

     EXPECT_EQ(complete_req, req);

     // Sent data should match payload of interrupt request.
     EXPECT_EQ(memcmp(send_buf, receive_buf, transfer_size), 0);

     usb_request_free(req);

     END_TEST;
 }

 // Test control and interrupt requests with 8 byte transfer size.
 bool control_interrupt_test_8() {
     return control_interrupt_test(8);
 }

 // Test control and interrupt requests with 64 byte transfer size.
 bool control_interrupt_test_64() {
     return control_interrupt_test(64);
 }

 // Test control and interrupt requests with 100 byte transfer size.
 bool control_interrupt_test_100() {
     return control_interrupt_test(100);
 }

 // Test control and interrupt requests with 256 byte transfer size.
 bool control_interrupt_test_256() {
     return control_interrupt_test(256);
 }

 // Test control and interrupt requests with 1000 byte transfer size.
 bool control_interrupt_test_1000() {
     return control_interrupt_test(1000);
 }

 // Tests bulk OUT and IN transfers.
 // Send BUFFER_SIZE bytes to device, read back and compare.
 bool bulk_test() {
     BEGIN_TEST;

     auto* send_req = usb_request_new(dev, bulk_out_ep);
     EXPECT_NE(send_req, nullptr);
     send_req->buffer = send_buf;
     send_req->buffer_length = static_cast<int>(BUFFER_SIZE);

     auto* receive_req = usb_request_new(dev, bulk_in_ep);
     EXPECT_NE(send_req, nullptr);
     receive_req->buffer = receive_buf;
     receive_req->buffer_length = static_cast<int>(BUFFER_SIZE);

     for (int i = 0; i < 10; i++) {
         randomize();

         // Create a thread to wait for request completions.
         auto thread_func = [](struct usb_request** reqs) -> void {
             *reqs++ = usb_request_wait(dev, TIMEOUT);
             *reqs = usb_request_wait(dev, TIMEOUT);
         };
         struct usb_request* complete_reqs[2] = {};
         std::thread wait_thread (thread_func, complete_reqs);

         // Queue requests in both directions
         int ret = usb_request_queue(receive_req);
         EXPECT_EQ(ret, 0);
         ret = usb_request_queue(send_req);
         EXPECT_EQ(ret, 0);

         wait_thread.join();

         EXPECT_NE(complete_reqs[0], nullptr);
         EXPECT_NE(complete_reqs[1], nullptr);

         // Sent and received data should match.
         EXPECT_EQ(memcmp(send_buf, receive_buf, BUFFER_SIZE), 0);
     }

     usb_request_free(send_req);
     usb_request_free(receive_req);

     END_TEST;
 }

 // usb_host_load() will call this for all connected USB devices.
 int usb_device_added(const char *dev_name, void *client_data) {
     usb_descriptor_iter iter;
     struct usb_descriptor_header* header;
     struct usb_interface_descriptor* intf = nullptr;
     int ret;

     dev = usb_device_open(dev_name);
     if (!dev) {
         fprintf(stderr, "usb_device_open failed for %s\n", dev_name);
         return 0;
     }

     uint16_t vid = usb_device_get_vendor_id(dev);
     uint16_t pid = usb_device_get_product_id(dev);

     if (vid != GOOGLE_USB_VID || pid != GOOGLE_USB_PERIPHERAL_TEST_PID) {
         // Device doesn't match, so keep looking.
         usb_device_close(dev);
         dev = nullptr;
         return 0;
     }

     usb_descriptor_iter_init(dev, &iter);

     while ((header = usb_descriptor_iter_next(&iter)) != nullptr) {
         if (header->bDescriptorType == USB_DT_INTERFACE) {
             intf = reinterpret_cast<struct usb_interface_descriptor*>(header);
         } else if (header->bDescriptorType == USB_DT_ENDPOINT) {
             auto* ep = reinterpret_cast<struct usb_endpoint_descriptor*>(header);
             if (usb_endpoint_type(ep) == USB_ENDPOINT_XFER_BULK) {
                 if (usb_endpoint_dir_in(ep)) {
                     bulk_in_ep = ep;
                 } else {
                     bulk_out_ep = ep;
                 }
             } else if (usb_endpoint_type(ep) == USB_ENDPOINT_XFER_INT) {
                 intr_ep = ep;
             }
         }
     }

     if (!intf || !bulk_out_ep || !bulk_in_ep || !intr_ep) {
         fprintf(stderr, "could not find all our endpoints\n");
         goto fail;
     }

     ret = usb_device_claim_interface(dev, intf->bInterfaceNumber);
     if (ret < 0) {
         fprintf(stderr, "usb_device_claim_interface failed\n");
         goto fail;
     }

     // Device found, exit from usb_host_load().
     return 1;

 fail:
     usb_device_close(dev);
     dev = nullptr;
     // Test done, exit from usb_host_load().
     return 1;
 }

 int usb_device_removed(const char *dev_name, void *client_data) {
     return 0;
 }

 int usb_discovery_done(void *client_data) {
     return 0;
 }

 } // anonymous namespace

 BEGIN_TEST_CASE(usb_peripheral_tests)
 RUN_TEST(control_interrupt_test_8);
 RUN_TEST(control_interrupt_test_64);
 RUN_TEST(control_interrupt_test_100);
 RUN_TEST(control_interrupt_test_256);
 RUN_TEST(control_interrupt_test_1000);
 RUN_TEST(bulk_test);
 END_TEST_CASE(usb_peripheral_tests)

 int main(int argc, char** argv) {
     struct usb_host_context* context = usb_host_init();
     if (!context) {
         fprintf(stderr, "usb_host_context failed\n");
         return -1;
     }
     auto cleanup = fbl::MakeAutoCall([&]() {
         usb_host_cleanup(context);
     });

     auto ret = usb_host_load(context, usb_device_added, usb_device_removed, usb_discovery_done,
                              nullptr);
     if (ret < 0) {
         fprintf(stderr, "usb_host_load failed!\n");
         goto fail;
     }
     if (!dev) {
         fprintf(stderr, "No device found, skipping tests.\n");
         goto fail;
     }

     ret = unittest_run_all_tests(argc, argv) ? 0 : -1;

 fail:
     if (dev) {
         usb_device_close(dev);
     }

     return ret;
 }
	// 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 <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <thread>

	#include <fbl/auto_call.h>
	#include <usbhost/usbhost.h>
	#include <unittest/unittest.h>
	#include <zircon/device/usb-peripheral-test.h>
	#include <zircon/device/usb-peripheral.h>

	namespace {

	struct usb_device* dev = nullptr;
	struct usb_endpoint_descriptor* bulk_out_ep = nullptr;
	struct usb_endpoint_descriptor* bulk_in_ep = nullptr;
	struct usb_endpoint_descriptor* intr_ep = nullptr;

	constexpr size_t BUFFER_SIZE = 4096;

	// Data to send to the device
	uint8_t send_buf[BUFFER_SIZE] = {};
	// Buffer for receiving data from the device
	int receive_buf[BUFFER_SIZE] = {};

	constexpr int TIMEOUT = 1000; // 1 seecond


	// Fill send_buf with random values.
	void randomize() {
	// Generate some random data.
	for (size_t i = 0; i < sizeof(send_buf); i++) {
	send_buf[i] = static_cast<uint8_t>(random());
	}
	}

	// Tests control and interrupt transfers with specified transfer size.
	bool control_interrupt_test(size_t transfer_size) {
	BEGIN_TEST;

	randomize();

	// Send data to device via OUT control request.
	int ret = usb_device_control_transfer(dev,
	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,
	USB_PERIPHERAL_TEST_SET_DATA, 0, 0, send_buf, transfer_size, TIMEOUT);
	EXPECT_EQ(ret, transfer_size);

	// Receive data back from device via IN control request.
	ret = usb_device_control_transfer(dev,
	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,
	USB_PERIPHERAL_TEST_GET_DATA, 0, 0, receive_buf, transfer_size,
	TIMEOUT);
	EXPECT_EQ(ret, transfer_size);

	// Sent and received data should match.
	EXPECT_EQ(memcmp(send_buf, receive_buf, transfer_size), 0);

	// Create a thread to wait for interrupt request.
	auto thread_func = [](struct usb_request** req) -> void {
	*req = usb_request_wait(dev, TIMEOUT);
	};
	struct usb_request* complete_req = nullptr;
	std::thread wait_thread (thread_func, &complete_req);

	// Queue read for interrupt request
	auto* req = usb_request_new(dev, intr_ep);
	EXPECT_NE(req, nullptr);
	req->buffer = receive_buf;
	req->buffer_length = static_cast<int>(transfer_size);
	ret = usb_request_queue(req);
	EXPECT_EQ(ret, 0);

	// Ask the device to send us an interrupt request containing the data we sent earlier.
	ret = usb_device_control_transfer(dev,
	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_TYPE_VENDOR \| USB_RECIP_INTERFACE,
	USB_PERIPHERAL_TEST_SEND_INTERUPT, 0, 0, nullptr, 0, TIMEOUT);
	EXPECT_EQ(ret, 0);

	wait_thread.join();

	EXPECT_EQ(complete_req, req);

	// Sent data should match payload of interrupt request.
	EXPECT_EQ(memcmp(send_buf, receive_buf, transfer_size), 0);

	usb_request_free(req);

	END_TEST;
	}

	// Test control and interrupt requests with 8 byte transfer size.
	bool control_interrupt_test_8() {
	return control_interrupt_test(8);
	}

	// Test control and interrupt requests with 64 byte transfer size.
	bool control_interrupt_test_64() {
	return control_interrupt_test(64);
	}

	// Test control and interrupt requests with 100 byte transfer size.
	bool control_interrupt_test_100() {
	return control_interrupt_test(100);
	}

	// Test control and interrupt requests with 256 byte transfer size.
	bool control_interrupt_test_256() {
	return control_interrupt_test(256);
	}

	// Test control and interrupt requests with 1000 byte transfer size.
	bool control_interrupt_test_1000() {
	return control_interrupt_test(1000);
	}

	// Tests bulk OUT and IN transfers.
	// Send BUFFER_SIZE bytes to device, read back and compare.
	bool bulk_test() {
	BEGIN_TEST;

	auto* send_req = usb_request_new(dev, bulk_out_ep);
	EXPECT_NE(send_req, nullptr);
	send_req->buffer = send_buf;
	send_req->buffer_length = static_cast<int>(BUFFER_SIZE);

	auto* receive_req = usb_request_new(dev, bulk_in_ep);
	EXPECT_NE(send_req, nullptr);
	receive_req->buffer = receive_buf;
	receive_req->buffer_length = static_cast<int>(BUFFER_SIZE);

	for (int i = 0; i < 10; i++) {
	randomize();

	// Create a thread to wait for request completions.
	auto thread_func = [](struct usb_request** reqs) -> void {
	*reqs++ = usb_request_wait(dev, TIMEOUT);
	*reqs = usb_request_wait(dev, TIMEOUT);
	};
	struct usb_request* complete_reqs[2] = {};
	std::thread wait_thread (thread_func, complete_reqs);

	// Queue requests in both directions
	int ret = usb_request_queue(receive_req);
	EXPECT_EQ(ret, 0);
	ret = usb_request_queue(send_req);
	EXPECT_EQ(ret, 0);

	wait_thread.join();

	EXPECT_NE(complete_reqs[0], nullptr);
	EXPECT_NE(complete_reqs[1], nullptr);

	// Sent and received data should match.
	EXPECT_EQ(memcmp(send_buf, receive_buf, BUFFER_SIZE), 0);
	}

	usb_request_free(send_req);
	usb_request_free(receive_req);

	END_TEST;
	}

	// usb_host_load() will call this for all connected USB devices.
	int usb_device_added(const char dev_name, void client_data) {
	usb_descriptor_iter iter;
	struct usb_descriptor_header* header;
	struct usb_interface_descriptor* intf = nullptr;
	int ret;

	dev = usb_device_open(dev_name);
	if (!dev) {
	fprintf(stderr, "usb_device_open failed for %s\n", dev_name);
	return 0;
	}

	uint16_t vid = usb_device_get_vendor_id(dev);
	uint16_t pid = usb_device_get_product_id(dev);

	if (vid != GOOGLE_USB_VID \|\| pid != GOOGLE_USB_PERIPHERAL_TEST_PID) {
	// Device doesn't match, so keep looking.
	usb_device_close(dev);
	dev = nullptr;
	return 0;
	}

	usb_descriptor_iter_init(dev, &iter);

	while ((header = usb_descriptor_iter_next(&iter)) != nullptr) {
	if (header->bDescriptorType == USB_DT_INTERFACE) {
	intf = reinterpret_cast<struct usb_interface_descriptor*>(header);
	} else if (header->bDescriptorType == USB_DT_ENDPOINT) {
	auto* ep = reinterpret_cast<struct usb_endpoint_descriptor*>(header);
	if (usb_endpoint_type(ep) == USB_ENDPOINT_XFER_BULK) {
	if (usb_endpoint_dir_in(ep)) {
	bulk_in_ep = ep;
	} else {
	bulk_out_ep = ep;
	}
	} else if (usb_endpoint_type(ep) == USB_ENDPOINT_XFER_INT) {
	intr_ep = ep;
	}
	}
	}

	if (!intf \|\| !bulk_out_ep \|\| !bulk_in_ep \|\| !intr_ep) {
	fprintf(stderr, "could not find all our endpoints\n");
	goto fail;
	}

	ret = usb_device_claim_interface(dev, intf->bInterfaceNumber);
	if (ret < 0) {
	fprintf(stderr, "usb_device_claim_interface failed\n");
	goto fail;
	}

	// Device found, exit from usb_host_load().
	return 1;

	fail:
	usb_device_close(dev);
	dev = nullptr;
	// Test done, exit from usb_host_load().
	return 1;
	}

	int usb_device_removed(const char dev_name, void client_data) {
	return 0;
	}

	int usb_discovery_done(void *client_data) {
	return 0;
	}

	} // anonymous namespace

	BEGIN_TEST_CASE(usb_peripheral_tests)
	RUN_TEST(control_interrupt_test_8);
	RUN_TEST(control_interrupt_test_64);
	RUN_TEST(control_interrupt_test_100);
	RUN_TEST(control_interrupt_test_256);
	RUN_TEST(control_interrupt_test_1000);
	RUN_TEST(bulk_test);
	END_TEST_CASE(usb_peripheral_tests)

	int main(int argc, char** argv) {
	struct usb_host_context* context = usb_host_init();
	if (!context) {
	fprintf(stderr, "usb_host_context failed\n");
	return -1;
	}
	auto cleanup = fbl::MakeAutoCall([&]() {
	usb_host_cleanup(context);
	});

	auto ret = usb_host_load(context, usb_device_added, usb_device_removed, usb_discovery_done,
	nullptr);
	if (ret < 0) {
	fprintf(stderr, "usb_host_load failed!\n");
	goto fail;
	}
	if (!dev) {
	fprintf(stderr, "No device found, skipping tests.\n");
	goto fail;
	}

	ret = unittest_run_all_tests(argc, argv) ? 0 : -1;

	fail:
	if (dev) {
	usb_device_close(dev);
	}

	return ret;
	}