1 /* 2 * ffs-test.c.c -- user mode filesystem api for usb composite function 3 * 4 * Copyright (C) 2010 Samsung Electronics 5 * Author: Michal Nazarewicz <mina86@mina86.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 /* $(CROSS_COMPILE)cc -Wall -Wextra -g -o ffs-test ffs-test.c -lpthread */ 23 24 25 #define _BSD_SOURCE /* for endian.h */ 26 27 #include <endian.h> 28 #include <errno.h> 29 #include <fcntl.h> 30 #include <pthread.h> 31 #include <stdarg.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <sys/ioctl.h> 36 #include <sys/stat.h> 37 #include <sys/types.h> 38 #include <unistd.h> 39 #include <tools/le_byteshift.h> 40 41 #include "../../include/linux/usb/functionfs.h" 42 43 44 /******************** Little Endian Handling ********************************/ 45 46 #define cpu_to_le16(x) htole16(x) 47 #define cpu_to_le32(x) htole32(x) 48 #define le32_to_cpu(x) le32toh(x) 49 #define le16_to_cpu(x) le16toh(x) 50 51 52 /******************** Messages and Errors ***********************************/ 53 54 static const char argv0[] = "ffs-test"; 55 56 static unsigned verbosity = 7; 57 58 static void _msg(unsigned level, const char *fmt, ...) 59 { 60 if (level < 2) 61 level = 2; 62 else if (level > 7) 63 level = 7; 64 65 if (level <= verbosity) { 66 static const char levels[8][6] = { 67 [2] = "crit:", 68 [3] = "err: ", 69 [4] = "warn:", 70 [5] = "note:", 71 [6] = "info:", 72 [7] = "dbg: " 73 }; 74 75 int _errno = errno; 76 va_list ap; 77 78 fprintf(stderr, "%s: %s ", argv0, levels[level]); 79 va_start(ap, fmt); 80 vfprintf(stderr, fmt, ap); 81 va_end(ap); 82 83 if (fmt[strlen(fmt) - 1] != '\n') { 84 char buffer[128]; 85 strerror_r(_errno, buffer, sizeof buffer); 86 fprintf(stderr, ": (-%d) %s\n", _errno, buffer); 87 } 88 89 fflush(stderr); 90 } 91 } 92 93 #define die(...) (_msg(2, __VA_ARGS__), exit(1)) 94 #define err(...) _msg(3, __VA_ARGS__) 95 #define warn(...) _msg(4, __VA_ARGS__) 96 #define note(...) _msg(5, __VA_ARGS__) 97 #define info(...) _msg(6, __VA_ARGS__) 98 #define debug(...) _msg(7, __VA_ARGS__) 99 100 #define die_on(cond, ...) do { \ 101 if (cond) \ 102 die(__VA_ARGS__); \ 103 } while (0) 104 105 106 /******************** Descriptors and Strings *******************************/ 107 108 static const struct { 109 struct usb_functionfs_descs_head header; 110 struct { 111 struct usb_interface_descriptor intf; 112 struct usb_endpoint_descriptor_no_audio sink; 113 struct usb_endpoint_descriptor_no_audio source; 114 } __attribute__((packed)) fs_descs, hs_descs; 115 } __attribute__((packed)) descriptors = { 116 .header = { 117 .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC), 118 .length = cpu_to_le32(sizeof descriptors), 119 .fs_count = 3, 120 .hs_count = 3, 121 }, 122 .fs_descs = { 123 .intf = { 124 .bLength = sizeof descriptors.fs_descs.intf, 125 .bDescriptorType = USB_DT_INTERFACE, 126 .bNumEndpoints = 2, 127 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 128 .iInterface = 1, 129 }, 130 .sink = { 131 .bLength = sizeof descriptors.fs_descs.sink, 132 .bDescriptorType = USB_DT_ENDPOINT, 133 .bEndpointAddress = 1 | USB_DIR_IN, 134 .bmAttributes = USB_ENDPOINT_XFER_BULK, 135 /* .wMaxPacketSize = autoconfiguration (kernel) */ 136 }, 137 .source = { 138 .bLength = sizeof descriptors.fs_descs.source, 139 .bDescriptorType = USB_DT_ENDPOINT, 140 .bEndpointAddress = 2 | USB_DIR_OUT, 141 .bmAttributes = USB_ENDPOINT_XFER_BULK, 142 /* .wMaxPacketSize = autoconfiguration (kernel) */ 143 }, 144 }, 145 .hs_descs = { 146 .intf = { 147 .bLength = sizeof descriptors.fs_descs.intf, 148 .bDescriptorType = USB_DT_INTERFACE, 149 .bNumEndpoints = 2, 150 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 151 .iInterface = 1, 152 }, 153 .sink = { 154 .bLength = sizeof descriptors.hs_descs.sink, 155 .bDescriptorType = USB_DT_ENDPOINT, 156 .bEndpointAddress = 1 | USB_DIR_IN, 157 .bmAttributes = USB_ENDPOINT_XFER_BULK, 158 .wMaxPacketSize = cpu_to_le16(512), 159 }, 160 .source = { 161 .bLength = sizeof descriptors.hs_descs.source, 162 .bDescriptorType = USB_DT_ENDPOINT, 163 .bEndpointAddress = 2 | USB_DIR_OUT, 164 .bmAttributes = USB_ENDPOINT_XFER_BULK, 165 .wMaxPacketSize = cpu_to_le16(512), 166 .bInterval = 1, /* NAK every 1 uframe */ 167 }, 168 }, 169 }; 170 171 172 #define STR_INTERFACE_ "Source/Sink" 173 174 static const struct { 175 struct usb_functionfs_strings_head header; 176 struct { 177 __le16 code; 178 const char str1[sizeof STR_INTERFACE_]; 179 } __attribute__((packed)) lang0; 180 } __attribute__((packed)) strings = { 181 .header = { 182 .magic = cpu_to_le32(FUNCTIONFS_STRINGS_MAGIC), 183 .length = cpu_to_le32(sizeof strings), 184 .str_count = cpu_to_le32(1), 185 .lang_count = cpu_to_le32(1), 186 }, 187 .lang0 = { 188 cpu_to_le16(0x0409), /* en-us */ 189 STR_INTERFACE_, 190 }, 191 }; 192 193 #define STR_INTERFACE strings.lang0.str1 194 195 196 /******************** Files and Threads Handling ****************************/ 197 198 struct thread; 199 200 static ssize_t read_wrap(struct thread *t, void *buf, size_t nbytes); 201 static ssize_t write_wrap(struct thread *t, const void *buf, size_t nbytes); 202 static ssize_t ep0_consume(struct thread *t, const void *buf, size_t nbytes); 203 static ssize_t fill_in_buf(struct thread *t, void *buf, size_t nbytes); 204 static ssize_t empty_out_buf(struct thread *t, const void *buf, size_t nbytes); 205 206 207 static struct thread { 208 const char *const filename; 209 size_t buf_size; 210 211 ssize_t (*in)(struct thread *, void *, size_t); 212 const char *const in_name; 213 214 ssize_t (*out)(struct thread *, const void *, size_t); 215 const char *const out_name; 216 217 int fd; 218 pthread_t id; 219 void *buf; 220 ssize_t status; 221 } threads[] = { 222 { 223 "ep0", 4 * sizeof(struct usb_functionfs_event), 224 read_wrap, NULL, 225 ep0_consume, "<consume>", 226 0, 0, NULL, 0 227 }, 228 { 229 "ep1", 8 * 1024, 230 fill_in_buf, "<in>", 231 write_wrap, NULL, 232 0, 0, NULL, 0 233 }, 234 { 235 "ep2", 8 * 1024, 236 read_wrap, NULL, 237 empty_out_buf, "<out>", 238 0, 0, NULL, 0 239 }, 240 }; 241 242 243 static void init_thread(struct thread *t) 244 { 245 t->buf = malloc(t->buf_size); 246 die_on(!t->buf, "malloc"); 247 248 t->fd = open(t->filename, O_RDWR); 249 die_on(t->fd < 0, "%s", t->filename); 250 } 251 252 static void cleanup_thread(void *arg) 253 { 254 struct thread *t = arg; 255 int ret, fd; 256 257 fd = t->fd; 258 if (t->fd < 0) 259 return; 260 t->fd = -1; 261 262 /* test the FIFO ioctls (non-ep0 code paths) */ 263 if (t != threads) { 264 ret = ioctl(fd, FUNCTIONFS_FIFO_STATUS); 265 if (ret < 0) { 266 /* ENODEV reported after disconnect */ 267 if (errno != ENODEV) 268 err("%s: get fifo status", t->filename); 269 } else if (ret) { 270 warn("%s: unclaimed = %d\n", t->filename, ret); 271 if (ioctl(fd, FUNCTIONFS_FIFO_FLUSH) < 0) 272 err("%s: fifo flush", t->filename); 273 } 274 } 275 276 if (close(fd) < 0) 277 err("%s: close", t->filename); 278 279 free(t->buf); 280 t->buf = NULL; 281 } 282 283 static void *start_thread_helper(void *arg) 284 { 285 const char *name, *op, *in_name, *out_name; 286 struct thread *t = arg; 287 ssize_t ret; 288 289 info("%s: starts\n", t->filename); 290 in_name = t->in_name ? t->in_name : t->filename; 291 out_name = t->out_name ? t->out_name : t->filename; 292 293 pthread_cleanup_push(cleanup_thread, arg); 294 295 for (;;) { 296 pthread_testcancel(); 297 298 ret = t->in(t, t->buf, t->buf_size); 299 if (ret > 0) { 300 ret = t->out(t, t->buf, t->buf_size); 301 name = out_name; 302 op = "write"; 303 } else { 304 name = in_name; 305 op = "read"; 306 } 307 308 if (ret > 0) { 309 /* nop */ 310 } else if (!ret) { 311 debug("%s: %s: EOF", name, op); 312 break; 313 } else if (errno == EINTR || errno == EAGAIN) { 314 debug("%s: %s", name, op); 315 } else { 316 warn("%s: %s", name, op); 317 break; 318 } 319 } 320 321 pthread_cleanup_pop(1); 322 323 t->status = ret; 324 info("%s: ends\n", t->filename); 325 return NULL; 326 } 327 328 static void start_thread(struct thread *t) 329 { 330 debug("%s: starting\n", t->filename); 331 332 die_on(pthread_create(&t->id, NULL, start_thread_helper, t) < 0, 333 "pthread_create(%s)", t->filename); 334 } 335 336 static void join_thread(struct thread *t) 337 { 338 int ret = pthread_join(t->id, NULL); 339 340 if (ret < 0) 341 err("%s: joining thread", t->filename); 342 else 343 debug("%s: joined\n", t->filename); 344 } 345 346 347 static ssize_t read_wrap(struct thread *t, void *buf, size_t nbytes) 348 { 349 return read(t->fd, buf, nbytes); 350 } 351 352 static ssize_t write_wrap(struct thread *t, const void *buf, size_t nbytes) 353 { 354 return write(t->fd, buf, nbytes); 355 } 356 357 358 /******************** Empty/Fill buffer routines ****************************/ 359 360 /* 0 -- stream of zeros, 1 -- i % 63, 2 -- pipe */ 361 enum pattern { PAT_ZERO, PAT_SEQ, PAT_PIPE }; 362 static enum pattern pattern; 363 364 static ssize_t 365 fill_in_buf(struct thread *ignore, void *buf, size_t nbytes) 366 { 367 size_t i; 368 __u8 *p; 369 370 (void)ignore; 371 372 switch (pattern) { 373 case PAT_ZERO: 374 memset(buf, 0, nbytes); 375 break; 376 377 case PAT_SEQ: 378 for (p = buf, i = 0; i < nbytes; ++i, ++p) 379 *p = i % 63; 380 break; 381 382 case PAT_PIPE: 383 return fread(buf, 1, nbytes, stdin); 384 } 385 386 return nbytes; 387 } 388 389 static ssize_t 390 empty_out_buf(struct thread *ignore, const void *buf, size_t nbytes) 391 { 392 const __u8 *p; 393 __u8 expected; 394 ssize_t ret; 395 size_t len; 396 397 (void)ignore; 398 399 switch (pattern) { 400 case PAT_ZERO: 401 expected = 0; 402 for (p = buf, len = 0; len < nbytes; ++p, ++len) 403 if (*p) 404 goto invalid; 405 break; 406 407 case PAT_SEQ: 408 for (p = buf, len = 0; len < nbytes; ++p, ++len) 409 if (*p != len % 63) { 410 expected = len % 63; 411 goto invalid; 412 } 413 break; 414 415 case PAT_PIPE: 416 ret = fwrite(buf, nbytes, 1, stdout); 417 if (ret > 0) 418 fflush(stdout); 419 break; 420 421 invalid: 422 err("bad OUT byte %zd, expected %02x got %02x\n", 423 len, expected, *p); 424 for (p = buf, len = 0; len < nbytes; ++p, ++len) { 425 if (0 == (len % 32)) 426 fprintf(stderr, "%4zd:", len); 427 fprintf(stderr, " %02x", *p); 428 if (31 == (len % 32)) 429 fprintf(stderr, "\n"); 430 } 431 fflush(stderr); 432 errno = EILSEQ; 433 return -1; 434 } 435 436 return len; 437 } 438 439 440 /******************** Endpoints routines ************************************/ 441 442 static void handle_setup(const struct usb_ctrlrequest *setup) 443 { 444 printf("bRequestType = %d\n", setup->bRequestType); 445 printf("bRequest = %d\n", setup->bRequest); 446 printf("wValue = %d\n", le16_to_cpu(setup->wValue)); 447 printf("wIndex = %d\n", le16_to_cpu(setup->wIndex)); 448 printf("wLength = %d\n", le16_to_cpu(setup->wLength)); 449 } 450 451 static ssize_t 452 ep0_consume(struct thread *ignore, const void *buf, size_t nbytes) 453 { 454 static const char *const names[] = { 455 [FUNCTIONFS_BIND] = "BIND", 456 [FUNCTIONFS_UNBIND] = "UNBIND", 457 [FUNCTIONFS_ENABLE] = "ENABLE", 458 [FUNCTIONFS_DISABLE] = "DISABLE", 459 [FUNCTIONFS_SETUP] = "SETUP", 460 [FUNCTIONFS_SUSPEND] = "SUSPEND", 461 [FUNCTIONFS_RESUME] = "RESUME", 462 }; 463 464 const struct usb_functionfs_event *event = buf; 465 size_t n; 466 467 (void)ignore; 468 469 for (n = nbytes / sizeof *event; n; --n, ++event) 470 switch (event->type) { 471 case FUNCTIONFS_BIND: 472 case FUNCTIONFS_UNBIND: 473 case FUNCTIONFS_ENABLE: 474 case FUNCTIONFS_DISABLE: 475 case FUNCTIONFS_SETUP: 476 case FUNCTIONFS_SUSPEND: 477 case FUNCTIONFS_RESUME: 478 printf("Event %s\n", names[event->type]); 479 if (event->type == FUNCTIONFS_SETUP) 480 handle_setup(&event->u.setup); 481 break; 482 483 default: 484 printf("Event %03u (unknown)\n", event->type); 485 } 486 487 return nbytes; 488 } 489 490 static void ep0_init(struct thread *t) 491 { 492 ssize_t ret; 493 494 info("%s: writing descriptors\n", t->filename); 495 ret = write(t->fd, &descriptors, sizeof descriptors); 496 die_on(ret < 0, "%s: write: descriptors", t->filename); 497 498 info("%s: writing strings\n", t->filename); 499 ret = write(t->fd, &strings, sizeof strings); 500 die_on(ret < 0, "%s: write: strings", t->filename); 501 } 502 503 504 /******************** Main **************************************************/ 505 506 int main(void) 507 { 508 unsigned i; 509 510 /* XXX TODO: Argument parsing missing */ 511 512 init_thread(threads); 513 ep0_init(threads); 514 515 for (i = 1; i < sizeof threads / sizeof *threads; ++i) 516 init_thread(threads + i); 517 518 for (i = 1; i < sizeof threads / sizeof *threads; ++i) 519 start_thread(threads + i); 520 521 start_thread_helper(threads); 522 523 for (i = 1; i < sizeof threads / sizeof *threads; ++i) 524 join_thread(threads + i); 525 526 return 0; 527 } 528