blob: 96616eb4600b4f917539148783f873772e1ed7b2 [file] [log] [blame]
/*
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* For more information, please refer to <http://unlicense.org/>
*/
/* $(CROSS_COMPILE)cc -g -o aio_simple aio_simple.c -laio */
#define _DEFAULT_SOURCE /* for endian.h */
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/poll.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/eventfd.h>
#include "libaio.h"
#define IOCB_FLAG_RESFD (1 << 0)
#include <linux/usb/functionfs.h>
#define BUF_LEN 8192
/*
* 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
/******************** Descriptors and Strings *******************************/
static const struct {
struct usb_functionfs_descs_head_v2 header;
__le32 fs_count;
__le32 hs_count;
struct {
struct usb_interface_descriptor intf;
struct usb_endpoint_descriptor_no_audio bulk_sink;
struct usb_endpoint_descriptor_no_audio bulk_source;
} __attribute__ ((__packed__)) fs_descs, hs_descs;
} __attribute__ ((__packed__)) descriptors = {
.header = {
.magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
.flags = cpu_to_le32(FUNCTIONFS_HAS_FS_DESC |
FUNCTIONFS_HAS_HS_DESC),
.length = cpu_to_le32(sizeof(descriptors)),
},
.fs_count = cpu_to_le32(3),
.fs_descs = {
.intf = {
.bLength = sizeof(descriptors.fs_descs.intf),
.bDescriptorType = USB_DT_INTERFACE,
.bNumEndpoints = 2,
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
.iInterface = 1,
},
.bulk_sink = {
.bLength = sizeof(descriptors.fs_descs.bulk_sink),
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 1 | USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
},
.bulk_source = {
.bLength = sizeof(descriptors.fs_descs.bulk_source),
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 2 | USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
},
},
.hs_count = cpu_to_le32(3),
.hs_descs = {
.intf = {
.bLength = sizeof(descriptors.hs_descs.intf),
.bDescriptorType = USB_DT_INTERFACE,
.bNumEndpoints = 2,
.bInterfaceClass = USB_CLASS_VENDOR_SPEC,
.iInterface = 1,
},
.bulk_sink = {
.bLength = sizeof(descriptors.hs_descs.bulk_sink),
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 1 | USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = cpu_to_le16(512),
},
.bulk_source = {
.bLength = sizeof(descriptors.hs_descs.bulk_source),
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 2 | USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = cpu_to_le16(512),
},
},
};
#define STR_INTERFACE "AIO Test"
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,
},
};
/******************** Endpoints handling *******************************/
static void display_event(struct usb_functionfs_event *event)
{
static const char *const names[] = {
[FUNCTIONFS_BIND] = "BIND",
[FUNCTIONFS_UNBIND] = "UNBIND",
[FUNCTIONFS_ENABLE] = "ENABLE",
[FUNCTIONFS_DISABLE] = "DISABLE",
[FUNCTIONFS_SETUP] = "SETUP",
[FUNCTIONFS_SUSPEND] = "SUSPEND",
[FUNCTIONFS_RESUME] = "RESUME",
};
switch (event->type) {
case FUNCTIONFS_BIND:
case FUNCTIONFS_UNBIND:
case FUNCTIONFS_ENABLE:
case FUNCTIONFS_DISABLE:
case FUNCTIONFS_SETUP:
case FUNCTIONFS_SUSPEND:
case FUNCTIONFS_RESUME:
printf("Event %s\n", names[event->type]);
}
}
static void handle_ep0(int ep0, bool *ready)
{
struct usb_functionfs_event event;
int ret;
struct pollfd pfds[1];
pfds[0].fd = ep0;
pfds[0].events = POLLIN;
ret = poll(pfds, 1, 0);
if (ret && (pfds[0].revents & POLLIN)) {
ret = read(ep0, &event, sizeof(event));
if (!ret) {
perror("unable to read event from ep0");
return;
}
display_event(&event);
switch (event.type) {
case FUNCTIONFS_SETUP:
if (event.u.setup.bRequestType & USB_DIR_IN)
write(ep0, NULL, 0);
else
read(ep0, NULL, 0);
break;
case FUNCTIONFS_ENABLE:
*ready = true;
break;
case FUNCTIONFS_DISABLE:
*ready = false;
break;
default:
break;
}
}
}
int main(int argc, char *argv[])
{
int i, ret;
char *ep_path;
int ep0;
int ep[2];
io_context_t ctx;
int evfd;
fd_set rfds;
char *buf_in, *buf_out;
struct iocb *iocb_in, *iocb_out;
int req_in = 0, req_out = 0;
bool ready;
if (argc != 2) {
printf("ffs directory not specified!\n");
return 1;
}
ep_path = malloc(strlen(argv[1]) + 4 /* "/ep#" */ + 1 /* '\0' */);
if (!ep_path) {
perror("malloc");
return 1;
}
/* open endpoint files */
sprintf(ep_path, "%s/ep0", argv[1]);
ep0 = open(ep_path, O_RDWR);
if (ep0 < 0) {
perror("unable to open ep0");
return 1;
}
if (write(ep0, &descriptors, sizeof(descriptors)) < 0) {
perror("unable do write descriptors");
return 1;
}
if (write(ep0, &strings, sizeof(strings)) < 0) {
perror("unable to write strings");
return 1;
}
for (i = 0; i < 2; ++i) {
sprintf(ep_path, "%s/ep%d", argv[1], i+1);
ep[i] = open(ep_path, O_RDWR);
if (ep[i] < 0) {
printf("unable to open ep%d: %s\n", i+1,
strerror(errno));
return 1;
}
}
free(ep_path);
memset(&ctx, 0, sizeof(ctx));
/* setup aio context to handle up to 2 requests */
if (io_setup(2, &ctx) < 0) {
perror("unable to setup aio");
return 1;
}
evfd = eventfd(0, 0);
if (evfd < 0) {
perror("unable to open eventfd");
return 1;
}
/* alloc buffers and requests */
buf_in = malloc(BUF_LEN);
buf_out = malloc(BUF_LEN);
iocb_in = malloc(sizeof(*iocb_in));
iocb_out = malloc(sizeof(*iocb_out));
while (1) {
FD_ZERO(&rfds);
FD_SET(ep0, &rfds);
FD_SET(evfd, &rfds);
ret = select(((ep0 > evfd) ? ep0 : evfd)+1,
&rfds, NULL, NULL, NULL);
if (ret < 0) {
if (errno == EINTR)
continue;
perror("select");
break;
}
if (FD_ISSET(ep0, &rfds))
handle_ep0(ep0, &ready);
/* we are waiting for function ENABLE */
if (!ready)
continue;
/* if something was submitted we wait for event */
if (FD_ISSET(evfd, &rfds)) {
uint64_t ev_cnt;
ret = read(evfd, &ev_cnt, sizeof(ev_cnt));
if (ret < 0) {
perror("unable to read eventfd");
break;
}
struct io_event e[2];
/* we wait for one event */
ret = io_getevents(ctx, 1, 2, e, NULL);
/* if we got event */
for (i = 0; i < ret; ++i) {
if (e[i].obj->aio_fildes == ep[0]) {
printf("ev=in; ret=%lu\n", e[i].res);
req_in = 0;
} else if (e[i].obj->aio_fildes == ep[1]) {
printf("ev=out; ret=%lu\n", e[i].res);
req_out = 0;
}
}
}
if (!req_in) { /* if IN transfer not requested*/
/* prepare write request */
io_prep_pwrite(iocb_in, ep[0], buf_in, BUF_LEN, 0);
/* enable eventfd notification */
iocb_in->u.c.flags |= IOCB_FLAG_RESFD;
iocb_in->u.c.resfd = evfd;
/* submit table of requests */
ret = io_submit(ctx, 1, &iocb_in);
if (ret >= 0) { /* if ret > 0 request is queued */
req_in = 1;
printf("submit: in\n");
} else
perror("unable to submit request");
}
if (!req_out) { /* if OUT transfer not requested */
/* prepare read request */
io_prep_pread(iocb_out, ep[1], buf_out, BUF_LEN, 0);
/* enable eventfs notification */
iocb_out->u.c.flags |= IOCB_FLAG_RESFD;
iocb_out->u.c.resfd = evfd;
/* submit table of requests */
ret = io_submit(ctx, 1, &iocb_out);
if (ret >= 0) { /* if ret > 0 request is queued */
req_out = 1;
printf("submit: out\n");
} else
perror("unable to submit request");
}
}
/* free resources */
io_destroy(ctx);
free(buf_in);
free(buf_out);
free(iocb_in);
free(iocb_out);
for (i = 0; i < 2; ++i)
close(ep[i]);
close(ep0);
return 0;
}