The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/tools/usb/testusb.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /* $(CROSS_COMPILE)cc -Wall -Wextra -g -lpthread -o testusb testusb.c */
    2 
    3 /*
    4  * Copyright (c) 2002 by David Brownell
    5  * Copyright (c) 2010 by Samsung Electronics
    6  * Author: Michal Nazarewicz <mina86@mina86.com>
    7  *
    8  * This program is free software; you can redistribute it and/or modify it
    9  * under the terms of the GNU General Public License as published by the
   10  * Free Software Foundation; either version 2 of the License, or (at your
   11  * option) any later version.
   12  *
   13  * This program is distributed in the hope that it will be useful, but
   14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   15  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   16  * for more details.
   17  *
   18  * You should have received a copy of the GNU General Public License
   19  * along with this program; if not, write to the Free Software Foundation,
   20  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   21  */
   22 
   23 /*
   24  * This program issues ioctls to perform the tests implemented by the
   25  * kernel driver.  It can generate a variety of transfer patterns; you
   26  * should make sure to test both regular streaming and mixes of
   27  * transfer sizes (including short transfers).
   28  *
   29  * For more information on how this can be used and on USB testing
   30  * refer to <URL:http://www.linux-usb.org/usbtest/>.
   31  */
   32 
   33 #include <stdio.h>
   34 #include <string.h>
   35 #include <ftw.h>
   36 #include <stdlib.h>
   37 #include <pthread.h>
   38 #include <unistd.h>
   39 #include <errno.h>
   40 #include <limits.h>
   41 
   42 #include <sys/types.h>
   43 #include <sys/stat.h>
   44 #include <fcntl.h>
   45 
   46 #include <sys/ioctl.h>
   47 #include <linux/usbdevice_fs.h>
   48 
   49 /*-------------------------------------------------------------------------*/
   50 
   51 #define TEST_CASES      30
   52 
   53 // FIXME make these public somewhere; usbdevfs.h?
   54 
   55 struct usbtest_param {
   56         // inputs
   57         unsigned                test_num;       /* 0..(TEST_CASES-1) */
   58         unsigned                iterations;
   59         unsigned                length;
   60         unsigned                vary;
   61         unsigned                sglen;
   62 
   63         // outputs
   64         struct timeval          duration;
   65 };
   66 #define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
   67 
   68 /*-------------------------------------------------------------------------*/
   69 
   70 /* #include <linux/usb_ch9.h> */
   71 
   72 #define USB_DT_DEVICE                   0x01
   73 #define USB_DT_INTERFACE                0x04
   74 
   75 #define USB_CLASS_PER_INTERFACE         0       /* for DeviceClass */
   76 #define USB_CLASS_VENDOR_SPEC           0xff
   77 
   78 
   79 struct usb_device_descriptor {
   80         __u8  bLength;
   81         __u8  bDescriptorType;
   82         __u16 bcdUSB;
   83         __u8  bDeviceClass;
   84         __u8  bDeviceSubClass;
   85         __u8  bDeviceProtocol;
   86         __u8  bMaxPacketSize0;
   87         __u16 idVendor;
   88         __u16 idProduct;
   89         __u16 bcdDevice;
   90         __u8  iManufacturer;
   91         __u8  iProduct;
   92         __u8  iSerialNumber;
   93         __u8  bNumConfigurations;
   94 } __attribute__ ((packed));
   95 
   96 struct usb_interface_descriptor {
   97         __u8  bLength;
   98         __u8  bDescriptorType;
   99 
  100         __u8  bInterfaceNumber;
  101         __u8  bAlternateSetting;
  102         __u8  bNumEndpoints;
  103         __u8  bInterfaceClass;
  104         __u8  bInterfaceSubClass;
  105         __u8  bInterfaceProtocol;
  106         __u8  iInterface;
  107 } __attribute__ ((packed));
  108 
  109 enum usb_device_speed {
  110         USB_SPEED_UNKNOWN = 0,                  /* enumerating */
  111         USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
  112         USB_SPEED_HIGH                          /* usb 2.0 */
  113 };
  114 
  115 /*-------------------------------------------------------------------------*/
  116 
  117 static char *speed (enum usb_device_speed s)
  118 {
  119         switch (s) {
  120         case USB_SPEED_UNKNOWN: return "unknown";
  121         case USB_SPEED_LOW:     return "low";
  122         case USB_SPEED_FULL:    return "full";
  123         case USB_SPEED_HIGH:    return "high";
  124         default:                return "??";
  125         }
  126 }
  127 
  128 struct testdev {
  129         struct testdev          *next;
  130         char                    *name;
  131         pthread_t               thread;
  132         enum usb_device_speed   speed;
  133         unsigned                ifnum : 8;
  134         unsigned                forever : 1;
  135         int                     test;
  136 
  137         struct usbtest_param    param;
  138 };
  139 static struct testdev           *testdevs;
  140 
  141 static int testdev_ffs_ifnum(FILE *fd)
  142 {
  143         union {
  144                 char buf[255];
  145                 struct usb_interface_descriptor intf;
  146         } u;
  147 
  148         for (;;) {
  149                 if (fread(u.buf, 1, 1, fd) != 1)
  150                         return -1;
  151                 if (fread(u.buf + 1, (unsigned char)u.buf[0] - 1, 1, fd) != 1)
  152                         return -1;
  153 
  154                 if (u.intf.bLength == sizeof u.intf
  155                  && u.intf.bDescriptorType == USB_DT_INTERFACE
  156                  && u.intf.bNumEndpoints == 2
  157                  && u.intf.bInterfaceClass == USB_CLASS_VENDOR_SPEC
  158                  && u.intf.bInterfaceSubClass == 0
  159                  && u.intf.bInterfaceProtocol == 0)
  160                         return (unsigned char)u.intf.bInterfaceNumber;
  161         }
  162 }
  163 
  164 static int testdev_ifnum(FILE *fd)
  165 {
  166         struct usb_device_descriptor dev;
  167 
  168         if (fread(&dev, sizeof dev, 1, fd) != 1)
  169                 return -1;
  170 
  171         if (dev.bLength != sizeof dev || dev.bDescriptorType != USB_DT_DEVICE)
  172                 return -1;
  173 
  174         /* FX2 with (tweaked) bulksrc firmware */
  175         if (dev.idVendor == 0x0547 && dev.idProduct == 0x1002)
  176                 return 0;
  177 
  178         /*----------------------------------------------------*/
  179 
  180         /* devices that start up using the EZ-USB default device and
  181          * which we can use after loading simple firmware.  hotplug
  182          * can fxload it, and then run this test driver.
  183          *
  184          * we return false positives in two cases:
  185          * - the device has a "real" driver (maybe usb-serial) that
  186          *   renumerates.  the device should vanish quickly.
  187          * - the device doesn't have the test firmware installed.
  188          */
  189 
  190         /* generic EZ-USB FX controller */
  191         if (dev.idVendor == 0x0547 && dev.idProduct == 0x2235)
  192                 return 0;
  193 
  194         /* generic EZ-USB FX2 controller */
  195         if (dev.idVendor == 0x04b4 && dev.idProduct == 0x8613)
  196                 return 0;
  197 
  198         /* CY3671 development board with EZ-USB FX */
  199         if (dev.idVendor == 0x0547 && dev.idProduct == 0x0080)
  200                 return 0;
  201 
  202         /* Keyspan 19Qi uses an21xx (original EZ-USB) */
  203         if (dev.idVendor == 0x06cd && dev.idProduct == 0x010b)
  204                 return 0;
  205 
  206         /*----------------------------------------------------*/
  207 
  208         /* "gadget zero", Linux-USB test software */
  209         if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a0)
  210                 return 0;
  211 
  212         /* user mode subset of that */
  213         if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a4)
  214                 return testdev_ffs_ifnum(fd);
  215                 /* return 0; */
  216 
  217         /* iso version of usermode code */
  218         if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a3)
  219                 return 0;
  220 
  221         /* some GPL'd test firmware uses these IDs */
  222 
  223         if (dev.idVendor == 0xfff0 && dev.idProduct == 0xfff0)
  224                 return 0;
  225 
  226         /*----------------------------------------------------*/
  227 
  228         /* iBOT2 high speed webcam */
  229         if (dev.idVendor == 0x0b62 && dev.idProduct == 0x0059)
  230                 return 0;
  231 
  232         /*----------------------------------------------------*/
  233 
  234         /* the FunctionFS gadget can have the source/sink interface
  235          * anywhere.  We look for an interface descriptor that match
  236          * what we expect.  We ignore configuratiens thou. */
  237 
  238         if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4ac
  239          && (dev.bDeviceClass == USB_CLASS_PER_INTERFACE
  240           || dev.bDeviceClass == USB_CLASS_VENDOR_SPEC))
  241                 return testdev_ffs_ifnum(fd);
  242 
  243         return -1;
  244 }
  245 
  246 static int find_testdev(const char *name, const struct stat *sb, int flag)
  247 {
  248         FILE                            *fd;
  249         int                             ifnum;
  250         struct testdev                  *entry;
  251 
  252         (void)sb; /* unused */
  253 
  254         if (flag != FTW_F)
  255                 return 0;
  256 
  257         fd = fopen(name, "rb");
  258         if (!fd) {
  259                 perror(name);
  260                 return 0;
  261         }
  262 
  263         ifnum = testdev_ifnum(fd);
  264         fclose(fd);
  265         if (ifnum < 0)
  266                 return 0;
  267 
  268         entry = calloc(1, sizeof *entry);
  269         if (!entry)
  270                 goto nomem;
  271 
  272         entry->name = strdup(name);
  273         if (!entry->name) {
  274                 free(entry);
  275 nomem:
  276                 perror("malloc");
  277                 return 0;
  278         }
  279 
  280         entry->ifnum = ifnum;
  281 
  282         /* FIXME ask usbfs what speed; update USBDEVFS_CONNECTINFO so
  283          * it tells about high speed etc */
  284 
  285         fprintf(stderr, "%s speed\t%s\t%u\n",
  286                 speed(entry->speed), entry->name, entry->ifnum);
  287 
  288         entry->next = testdevs;
  289         testdevs = entry;
  290         return 0;
  291 }
  292 
  293 static int
  294 usbdev_ioctl (int fd, int ifno, unsigned request, void *param)
  295 {
  296         struct usbdevfs_ioctl   wrapper;
  297 
  298         wrapper.ifno = ifno;
  299         wrapper.ioctl_code = request;
  300         wrapper.data = param;
  301 
  302         return ioctl (fd, USBDEVFS_IOCTL, &wrapper);
  303 }
  304 
  305 static void *handle_testdev (void *arg)
  306 {
  307         struct testdev          *dev = arg;
  308         int                     fd, i;
  309         int                     status;
  310 
  311         if ((fd = open (dev->name, O_RDWR)) < 0) {
  312                 perror ("can't open dev file r/w");
  313                 return 0;
  314         }
  315 
  316 restart:
  317         for (i = 0; i < TEST_CASES; i++) {
  318                 if (dev->test != -1 && dev->test != i)
  319                         continue;
  320                 dev->param.test_num = i;
  321 
  322                 status = usbdev_ioctl (fd, dev->ifnum,
  323                                 USBTEST_REQUEST, &dev->param);
  324                 if (status < 0 && errno == EOPNOTSUPP)
  325                         continue;
  326 
  327                 /* FIXME need a "syslog it" option for background testing */
  328 
  329                 /* NOTE: each thread emits complete lines; no fragments! */
  330                 if (status < 0) {
  331                         char    buf [80];
  332                         int     err = errno;
  333 
  334                         if (strerror_r (errno, buf, sizeof buf)) {
  335                                 snprintf (buf, sizeof buf, "error %d", err);
  336                                 errno = err;
  337                         }
  338                         printf ("%s test %d --> %d (%s)\n",
  339                                 dev->name, i, errno, buf);
  340                 } else
  341                         printf ("%s test %d, %4d.%.06d secs\n", dev->name, i,
  342                                 (int) dev->param.duration.tv_sec,
  343                                 (int) dev->param.duration.tv_usec);
  344 
  345                 fflush (stdout);
  346         }
  347         if (dev->forever)
  348                 goto restart;
  349 
  350         close (fd);
  351         return arg;
  352 }
  353 
  354 static const char *usbfs_dir_find(void)
  355 {
  356         static char udev_usb_path[] = "/dev/bus/usb";
  357 
  358         if (access(udev_usb_path, F_OK) == 0)
  359                 return udev_usb_path;
  360 
  361         return NULL;
  362 }
  363 
  364 static int parse_num(unsigned *num, const char *str)
  365 {
  366         unsigned long val;
  367         char *end;
  368 
  369         errno = 0;
  370         val = strtoul(str, &end, 0);
  371         if (errno || *end || val > UINT_MAX)
  372                 return -1;
  373         *num = val;
  374         return 0;
  375 }
  376 
  377 int main (int argc, char **argv)
  378 {
  379 
  380         int                     c;
  381         struct testdev          *entry;
  382         char                    *device;
  383         const char              *usbfs_dir = NULL;
  384         int                     all = 0, forever = 0, not = 0;
  385         int                     test = -1 /* all */;
  386         struct usbtest_param    param;
  387 
  388         /* pick defaults that works with all speeds, without short packets.
  389          *
  390          * Best per-frame data rates:
  391          *     high speed, bulk       512 * 13 * 8 = 53248
  392          *                 interrupt 1024 *  3 * 8 = 24576
  393          *     full speed, bulk/intr   64 * 19     =  1216
  394          *                 interrupt   64 *  1     =    64
  395          *      low speed, interrupt    8 *  1     =     8
  396          */
  397         param.iterations = 1000;
  398         param.length = 512;
  399         param.vary = 512;
  400         param.sglen = 32;
  401 
  402         /* for easy use when hotplugging */
  403         device = getenv ("DEVICE");
  404 
  405         while ((c = getopt (argc, argv, "D:aA:c:g:hlns:t:v:")) != EOF)
  406         switch (c) {
  407         case 'D':       /* device, if only one */
  408                 device = optarg;
  409                 continue;
  410         case 'A':       /* use all devices with specified usbfs dir */
  411                 usbfs_dir = optarg;
  412                 /* FALL THROUGH */
  413         case 'a':       /* use all devices */
  414                 device = NULL;
  415                 all = 1;
  416                 continue;
  417         case 'c':       /* count iterations */
  418                 if (parse_num(&param.iterations, optarg))
  419                         goto usage;
  420                 continue;
  421         case 'g':       /* scatter/gather entries */
  422                 if (parse_num(&param.sglen, optarg))
  423                         goto usage;
  424                 continue;
  425         case 'l':       /* loop forever */
  426                 forever = 1;
  427                 continue;
  428         case 'n':       /* no test running! */
  429                 not = 1;
  430                 continue;
  431         case 's':       /* size of packet */
  432                 if (parse_num(&param.length, optarg))
  433                         goto usage;
  434                 continue;
  435         case 't':       /* run just one test */
  436                 test = atoi (optarg);
  437                 if (test < 0)
  438                         goto usage;
  439                 continue;
  440         case 'v':       /* vary packet size by ... */
  441                 if (parse_num(&param.vary, optarg))
  442                         goto usage;
  443                 continue;
  444         case '?':
  445         case 'h':
  446         default:
  447 usage:
  448                 fprintf (stderr,
  449                         "usage: %s [options]\n"
  450                         "Options:\n"
  451                         "\t-D dev               only test specific device\n"
  452                         "\t-A usbfs-dir\n"
  453                         "\t-a           test all recognized devices\n"
  454                         "\t-l           loop forever(for stress test)\n"
  455                         "\t-t testnum   only run specified case\n"
  456                         "\t-n           no test running, show devices to be tested\n"
  457                         "Case arguments:\n"
  458                         "\t-c iterations        default 1000\n"
  459                         "\t-s packetsize        default 512\n"
  460                         "\t-g sglen     default 32\n"
  461                         "\t-v vary              default 512\n",
  462                         argv[0]);
  463                 return 1;
  464         }
  465         if (optind != argc)
  466                 goto usage;
  467         if (!all && !device) {
  468                 fprintf (stderr, "must specify '-a' or '-D dev', "
  469                         "or DEVICE=/dev/bus/usb/BBB/DDD in env\n");
  470                 goto usage;
  471         }
  472 
  473         /* Find usbfs mount point */
  474         if (!usbfs_dir) {
  475                 usbfs_dir = usbfs_dir_find();
  476                 if (!usbfs_dir) {
  477                         fputs ("usbfs files are missing\n", stderr);
  478                         return -1;
  479                 }
  480         }
  481 
  482         /* collect and list the test devices */
  483         if (ftw (usbfs_dir, find_testdev, 3) != 0) {
  484                 fputs ("ftw failed; is usbfs missing?\n", stderr);
  485                 return -1;
  486         }
  487 
  488         /* quit, run single test, or create test threads */
  489         if (!testdevs && !device) {
  490                 fputs ("no test devices recognized\n", stderr);
  491                 return -1;
  492         }
  493         if (not)
  494                 return 0;
  495         if (testdevs && testdevs->next == 0 && !device)
  496                 device = testdevs->name;
  497         for (entry = testdevs; entry; entry = entry->next) {
  498                 int     status;
  499 
  500                 entry->param = param;
  501                 entry->forever = forever;
  502                 entry->test = test;
  503 
  504                 if (device) {
  505                         if (strcmp (entry->name, device))
  506                                 continue;
  507                         return handle_testdev (entry) != entry;
  508                 }
  509                 status = pthread_create (&entry->thread, 0, handle_testdev, entry);
  510                 if (status) {
  511                         perror ("pthread_create");
  512                         continue;
  513                 }
  514         }
  515         if (device) {
  516                 struct testdev          dev;
  517 
  518                 /* kernel can recognize test devices we don't */
  519                 fprintf (stderr, "%s: %s may see only control tests\n",
  520                                 argv [0], device);
  521 
  522                 memset (&dev, 0, sizeof dev);
  523                 dev.name = device;
  524                 dev.param = param;
  525                 dev.forever = forever;
  526                 dev.test = test;
  527                 return handle_testdev (&dev) != &dev;
  528         }
  529 
  530         /* wait for tests to complete */
  531         for (entry = testdevs; entry; entry = entry->next) {
  532                 void    *retval;
  533 
  534                 if (pthread_join (entry->thread, &retval))
  535                         perror ("pthread_join");
  536                 /* testing errors discarded! */
  537         }
  538 
  539         return 0;
  540 }

Cache object: a4c07f7fa717a62117fc9e68bbf5fcad


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.