dsynth - Don't double-add ports-mgmt/pkg
[dragonfly.git] / tools / tools / usbtest / usbtest.c
1 /* $FreeBSD: head/tools/tools/usbtest/usbtest.c 254159 2013-08-09 20:08:42Z hselasky $ */
2 /*-
3  * Copyright (c) 2010 Hans Petter Selasky. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26
27 #include <stdio.h>
28 #include <stdint.h>
29 #include <err.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <stdarg.h>
33 #include <stdlib.h>
34
35 #include <sys/types.h>
36 #include <sys/sysctl.h>
37
38 #include <bus/u4b/usb_ioctl.h>
39
40 #include "usbtest.h"
41
42 #include <g_keyboard.h>
43 #include <g_mouse.h>
44 #include <g_modem.h>
45 #include <g_audio.h>
46
47 static uint8_t usb_ts_select[USB_TS_MAX_LEVELS];
48
49 const char *indent[USB_TS_MAX_LEVELS] = {
50         " ",
51         "   ",
52         "     ",
53         "       ",
54         "         ",
55         "           ",
56         "             ",
57         "               ",
58 };
59
60 /* a perceptual white noise generator (after HPS' invention) */
61
62 int32_t
63 usb_ts_rand_noise(void)
64 {
65         uint32_t temp;
66         const uint32_t prime = 0xFFFF1D;
67         static uint32_t noise_rem = 1;
68
69         if (noise_rem & 1) {
70                 noise_rem += prime;
71         }
72         noise_rem /= 2;
73
74         temp = noise_rem;
75
76         /* unsigned to signed conversion */
77
78         temp ^= 0x800000;
79         if (temp & 0x800000) {
80                 temp |= (-0x800000);
81         }
82         return temp;
83 }
84
85 uint8_t
86 usb_ts_show_menu(uint8_t level, const char *title, const char *fmt,...)
87 {
88         va_list args;
89         uint8_t x;
90         uint8_t retval;
91         char *pstr;
92         char buf[16];
93         char menu[80 * 20];
94
95         va_start(args, fmt);
96         vsnprintf(menu, sizeof(menu), fmt, args);
97         va_end(args);
98
99         printf("[");
100
101         for (x = 0; x != level; x++) {
102                 if ((x + 1) == level)
103                         printf("%d", usb_ts_select[x]);
104                 else
105                         printf("%d.", usb_ts_select[x]);
106         }
107
108         printf("] - %s:\n\n", title);
109
110         x = 1;
111         for (pstr = menu; *pstr; pstr++) {
112                 if (x != 0) {
113                         printf("%s", indent[level]);
114                         x = 0;
115                 }
116                 printf("%c", *pstr);
117
118                 if (*pstr == '\n')
119                         x = 1;
120         }
121
122         printf("\n>");
123
124         if (fgets(buf, sizeof(buf), stdin) == NULL)
125                 err(1, "Cannot read input");
126
127         if (buf[0] == 'x')
128                 retval = 255;
129         else
130                 retval = atoi(buf);
131
132         usb_ts_select[level] = retval;
133
134         return (retval);
135 }
136
137 void
138 get_string(char *ptr, int size)
139 {
140         printf("\nEnter string>");
141
142         if (fgets(ptr, size, stdin) == NULL)
143                 err(1, "Cannot read input");
144
145         ptr[size - 1] = 0;
146
147         size = strlen(ptr);
148
149         /* strip trailing newline, if any */
150         if (size == 0)
151                 return;
152         else if (ptr[size - 1] == '\n')
153                 ptr[size - 1] = 0;
154 }
155
156 int
157 get_integer(void)
158 {
159         char buf[32];
160
161         printf("\nEnter integer value>");
162
163         if (fgets(buf, sizeof(buf), stdin) == NULL)
164                 err(1, "Cannot read input");
165
166         if (strcmp(buf, "x\n") == 0)
167                 return (-1);
168         if (strcmp(buf, "r\n") == 0)
169                 return (-2);
170
171         return ((int)strtol(buf, 0, 0));
172 }
173
174 static void
175 set_template(int template)
176 {
177         int error;
178
179         error = sysctlbyname("hw.usb.template", NULL, NULL,
180             &template, sizeof(template));
181
182         if (error != 0) {
183                 printf("WARNING: Could not set USB template "
184                     "to %d (error=%d)\n", template, errno);
185         }
186 }
187
188 static void
189 show_default_audio_select(uint8_t level)
190 {
191         int error;
192         int retval;
193         int mode = 0;
194         int pattern_interval = 128;
195         int throughput = 0;
196         size_t len;
197         char pattern[G_AUDIO_MAX_STRLEN] = {"0123456789abcdef"};
198
199         set_template(USB_TEMP_AUDIO);
200
201         while (1) {
202
203                 error = sysctlbyname("hw.usb.g_audio.mode", NULL, NULL,
204                     &mode, sizeof(mode));
205
206                 if (error != 0) {
207                         printf("WARNING: Could not set audio mode "
208                             "to %d (error=%d)\n", mode, errno);
209                 }
210                 error = sysctlbyname("hw.usb.g_audio.pattern_interval", NULL, NULL,
211                     &pattern_interval, sizeof(pattern_interval));
212
213                 if (error != 0) {
214                         printf("WARNING: Could not set pattern interval "
215                             "to %d (error=%d)\n", pattern_interval, errno);
216                 }
217                 len = sizeof(throughput);
218
219                 error = sysctlbyname("hw.usb.g_audio.throughput",
220                     &throughput, &len, 0, 0);
221
222                 if (error != 0) {
223                         printf("WARNING: Could not get throughput "
224                             "(error=%d)\n", errno);
225                 }
226                 error = sysctlbyname("hw.usb.g_audio.pattern", NULL, NULL,
227                     &pattern, strlen(pattern));
228
229                 if (error != 0) {
230                         printf("WARNING: Could not set audio pattern "
231                             "to '%s' (error=%d)\n", pattern, errno);
232                 }
233                 retval = usb_ts_show_menu(level, "Default Audio Settings",
234                     "1) Set Silent mode %s\n"
235                     "2) Set Dump mode %s\n"
236                     "3) Set Loop mode %s\n"
237                     "4) Set Pattern mode %s\n"
238                     "5) Change DTMF pattern: '%s'\n"
239                     "6) Change pattern advance interval: %d ms\n"
240                     "x) Return to previous menu\n"
241                     "s: Ready for enumeration\n"
242                     "t: Throughput: %d bytes/second\n",
243                     (mode == G_AUDIO_MODE_SILENT) ? "(selected)" : "",
244                     (mode == G_AUDIO_MODE_DUMP) ? "(selected)" : "",
245                     (mode == G_AUDIO_MODE_LOOP) ? "(selected)" : "",
246                     (mode == G_AUDIO_MODE_PATTERN) ? "(selected)" : "",
247                     pattern, pattern_interval, throughput);
248
249                 switch (retval) {
250                 case 0:
251                         break;
252                 case 1:
253                         mode = G_AUDIO_MODE_SILENT;
254                         break;
255                 case 2:
256                         mode = G_AUDIO_MODE_DUMP;
257                         break;
258                 case 3:
259                         mode = G_AUDIO_MODE_LOOP;
260                         break;
261                 case 4:
262                         mode = G_AUDIO_MODE_PATTERN;
263                         break;
264                 case 5:
265                         get_string(pattern, sizeof(pattern));
266                         break;
267                 case 6:
268                         pattern_interval = get_integer();
269                         break;
270                 default:
271                         return;
272                 }
273         }
274 }
275
276 static void
277 show_device_audio_select(uint8_t level)
278 {
279         uint8_t retval;
280
281         while (1) {
282
283                 retval = usb_ts_show_menu(level, "Select Audio Device Model",
284                     "1) Generic Audio Device\n"
285                     "x) Return to previous menu\n");
286
287                 switch (retval) {
288                 case 0:
289                         break;
290                 case 1:
291                         show_default_audio_select(level + 1);
292                         break;
293                 default:
294                         return;
295                 }
296         }
297 }
298
299 static void
300 show_device_msc_select(uint8_t level)
301 {
302         set_template(USB_TEMP_MSC);
303 }
304
305 static void
306 show_device_ethernet_select(uint8_t level)
307 {
308         set_template(USB_TEMP_CDCE);
309 }
310
311 static void
312 show_default_keyboard_select(uint8_t level)
313 {
314         int error;
315         int retval;
316         int mode = 0;
317         int interval = 1023;
318         char pattern[G_KEYBOARD_MAX_STRLEN] = {"abcdefpattern"};
319
320         set_template(USB_TEMP_KBD);
321
322         while (1) {
323
324                 error = sysctlbyname("hw.usb.g_keyboard.mode", NULL, NULL,
325                     &mode, sizeof(mode));
326
327                 if (error != 0) {
328                         printf("WARNING: Could not set keyboard mode "
329                             " to %d (error=%d) \n", mode, errno);
330                 }
331                 error = sysctlbyname("hw.usb.g_keyboard.key_press_interval", NULL, NULL,
332                     &interval, sizeof(interval));
333
334                 if (error != 0) {
335                         printf("WARNING: Could not set key press interval "
336                             "to %d (error=%d)\n", interval, errno);
337                 }
338                 error = sysctlbyname("hw.usb.g_keyboard.key_press_pattern", NULL, NULL,
339                     &pattern, strlen(pattern));
340
341                 if (error != 0) {
342                         printf("WARNING: Could not set key pattern "
343                             "to '%s' (error=%d)\n", pattern, errno);
344                 }
345                 retval = usb_ts_show_menu(level, "Default Keyboard Settings",
346                     "1) Set silent mode %s\n"
347                     "2) Set pattern mode %s\n"
348                     "3) Change pattern: '%s'\n"
349                     "4) Change key press interval: %d ms\n"
350                     "x) Return to previous menu\n"
351                     "s: Ready for enumeration\n",
352                     (mode == G_KEYBOARD_MODE_SILENT) ? "(selected)" : "",
353                     (mode == G_KEYBOARD_MODE_PATTERN) ? "(selected)" : "",
354                     pattern, interval);
355
356                 switch (retval) {
357                 case 0:
358                         break;
359                 case 1:
360                         mode = G_KEYBOARD_MODE_SILENT;
361                         break;
362                 case 2:
363                         mode = G_KEYBOARD_MODE_PATTERN;
364                         break;
365                 case 3:
366                         get_string(pattern, sizeof(pattern));
367                         break;
368                 case 4:
369                         interval = get_integer();
370                         break;
371                 default:
372                         return;
373                 }
374         }
375 }
376
377 static void
378 show_device_keyboard_select(uint8_t level)
379 {
380         uint8_t retval;
381
382         while (1) {
383
384                 retval = usb_ts_show_menu(level, "Select Keyboard Model",
385                     "1) Generic Keyboard \n"
386                     "x) Return to previous menu \n");
387
388                 switch (retval) {
389                 case 0:
390                         break;
391                 case 1:
392                         show_default_keyboard_select(level + 1);
393                         break;
394                 default:
395                         return;
396                 }
397         }
398 }
399
400 static void
401 show_default_mouse_select(uint8_t level)
402 {
403         int error;
404         int retval;
405         int mode = 0;
406         int cursor_interval = 128;
407         int cursor_radius = 75;
408         int button_interval = 0;
409
410         set_template(USB_TEMP_MOUSE);
411
412         while (1) {
413
414                 error = sysctlbyname("hw.usb.g_mouse.mode", NULL, NULL,
415                     &mode, sizeof(mode));
416
417                 if (error != 0) {
418                         printf("WARNING: Could not set mouse mode "
419                             "to %d (error=%d)\n", mode, errno);
420                 }
421                 error = sysctlbyname("hw.usb.g_mouse.cursor_update_interval", NULL, NULL,
422                     &cursor_interval, sizeof(cursor_interval));
423
424                 if (error != 0) {
425                         printf("WARNING: Could not set cursor update interval "
426                             "to %d (error=%d)\n", cursor_interval, errno);
427                 }
428                 error = sysctlbyname("hw.usb.g_mouse.button_press_interval", NULL, NULL,
429                     &button_interval, sizeof(button_interval));
430
431                 if (error != 0) {
432                         printf("WARNING: Could not set button press interval "
433                             "to %d (error=%d)\n", button_interval, errno);
434                 }
435                 error = sysctlbyname("hw.usb.g_mouse.cursor_radius", NULL, NULL,
436                     &cursor_radius, sizeof(cursor_radius));
437
438                 if (error != 0) {
439                         printf("WARNING: Could not set cursor radius "
440                             "to %d (error=%d)\n", cursor_radius, errno);
441                 }
442                 retval = usb_ts_show_menu(level, "Default Mouse Settings",
443                     "1) Set Silent mode %s\n"
444                     "2) Set Circle mode %s\n"
445                     "3) Set Square mode %s\n"
446                     "4) Set Spiral mode %s\n"
447                     "5) Change cursor radius: %d pixels\n"
448                     "6) Change cursor update interval: %d ms\n"
449                     "7) Change button[0] press interval: %d ms\n"
450                     "x) Return to previous menu\n"
451                     "s: Ready for enumeration\n",
452                     (mode == G_MOUSE_MODE_SILENT) ? "(selected)" : "",
453                     (mode == G_MOUSE_MODE_CIRCLE) ? "(selected)" : "",
454                     (mode == G_MOUSE_MODE_BOX) ? "(selected)" : "",
455                     (mode == G_MOUSE_MODE_SPIRAL) ? "(selected)" : "",
456                     cursor_radius, cursor_interval, button_interval);
457
458                 switch (retval) {
459                 case 0:
460                         break;
461                 case 1:
462                         mode = G_MOUSE_MODE_SILENT;
463                         break;
464                 case 2:
465                         mode = G_MOUSE_MODE_CIRCLE;
466                         break;
467                 case 3:
468                         mode = G_MOUSE_MODE_BOX;
469                         break;
470                 case 4:
471                         mode = G_MOUSE_MODE_SPIRAL;
472                         break;
473                 case 5:
474                         cursor_radius = get_integer();
475                         break;
476                 case 6:
477                         cursor_interval = get_integer();
478                         break;
479                 case 7:
480                         button_interval = get_integer();
481                         break;
482                 default:
483                         return;
484                 }
485         }
486 }
487
488 static void
489 show_device_mouse_select(uint8_t level)
490 {
491         uint8_t retval;
492
493         while (1) {
494
495                 retval = usb_ts_show_menu(level, "Select Mouse Model",
496                     "1) Generic Mouse\n"
497                     "x) Return to previous menu\n");
498
499                 switch (retval) {
500                 case 0:
501                         break;
502                 case 1:
503                         show_default_mouse_select(level + 1);
504                         break;
505                 default:
506                         return;
507                 }
508         }
509 }
510
511 static void
512 show_device_mtp_select(uint8_t level)
513 {
514         set_template(USB_TEMP_MTP);
515 }
516
517 static void
518 show_default_modem_select(uint8_t level)
519 {
520         int error;
521         int retval;
522         int mode = 0;
523         int pattern_interval = 128;
524         int throughput = 0;
525         size_t len;
526         char pattern[G_MODEM_MAX_STRLEN] = {"abcdefpattern"};
527
528         set_template(USB_TEMP_MODEM);
529
530         while (1) {
531
532                 error = sysctlbyname("hw.usb.g_modem.mode", NULL, NULL,
533                     &mode, sizeof(mode));
534
535                 if (error != 0) {
536                         printf("WARNING: Could not set modem mode "
537                             "to %d (error=%d)\n", mode, errno);
538                 }
539                 error = sysctlbyname("hw.usb.g_modem.pattern_interval", NULL, NULL,
540                     &pattern_interval, sizeof(pattern_interval));
541
542                 if (error != 0) {
543                         printf("WARNING: Could not set pattern interval "
544                             "to %d (error=%d)\n", pattern_interval, errno);
545                 }
546                 len = sizeof(throughput);
547
548                 error = sysctlbyname("hw.usb.g_modem.throughput",
549                     &throughput, &len, 0, 0);
550
551                 if (error != 0) {
552                         printf("WARNING: Could not get throughput "
553                             "(error=%d)\n", errno);
554                 }
555                 error = sysctlbyname("hw.usb.g_modem.pattern", NULL, NULL,
556                     &pattern, strlen(pattern));
557
558                 if (error != 0) {
559                         printf("WARNING: Could not set modem pattern "
560                             "to '%s' (error=%d)\n", pattern, errno);
561                 }
562                 retval = usb_ts_show_menu(level, "Default Modem Settings",
563                     "1) Set Silent mode %s\n"
564                     "2) Set Dump mode %s\n"
565                     "3) Set Loop mode %s\n"
566                     "4) Set Pattern mode %s\n"
567                     "5) Change test pattern: '%s'\n"
568                     "6) Change data transmit interval: %d ms\n"
569                     "x) Return to previous menu\n"
570                     "s: Ready for enumeration\n"
571                     "t: Throughput: %d bytes/second\n",
572                     (mode == G_MODEM_MODE_SILENT) ? "(selected)" : "",
573                     (mode == G_MODEM_MODE_DUMP) ? "(selected)" : "",
574                     (mode == G_MODEM_MODE_LOOP) ? "(selected)" : "",
575                     (mode == G_MODEM_MODE_PATTERN) ? "(selected)" : "",
576                     pattern, pattern_interval, throughput);
577
578                 switch (retval) {
579                 case 0:
580                         break;
581                 case 1:
582                         mode = G_MODEM_MODE_SILENT;
583                         break;
584                 case 2:
585                         mode = G_MODEM_MODE_DUMP;
586                         break;
587                 case 3:
588                         mode = G_MODEM_MODE_LOOP;
589                         break;
590                 case 4:
591                         mode = G_MODEM_MODE_PATTERN;
592                         break;
593                 case 5:
594                         get_string(pattern, sizeof(pattern));
595                         break;
596                 case 6:
597                         pattern_interval = get_integer();
598                         break;
599                 default:
600                         return;
601                 }
602         }
603 }
604
605 static void
606 show_device_modem_select(uint8_t level)
607 {
608         uint8_t retval;
609
610         while (1) {
611
612                 retval = usb_ts_show_menu(level, "Select Modem Model",
613                     "1) Generic Modem\n"
614                     "x) Return to previous menu\n");
615
616                 switch (retval) {
617                 case 0:
618                         break;
619                 case 1:
620                         show_default_modem_select(level + 1);
621                         break;
622                 default:
623                         return;
624                 }
625         }
626 }
627
628 static void
629 show_device_generic_select(uint8_t level)
630 {
631 }
632
633 static void
634 show_device_select(uint8_t level)
635 {
636         uint8_t retval;
637
638         while (1) {
639
640                 retval = usb_ts_show_menu(level, "Select Device Mode Test Group",
641                     "1) Audio (UAUDIO)\n"
642                     "2) Mass Storage (MSC)\n"
643                     "3) Ethernet (CDCE)\n"
644                     "4) Keyboard Input Device (UKBD)\n"
645                     "5) Mouse Input Device (UMS)\n"
646                     "6) Message Transfer Protocol (MTP)\n"
647                     "7) Modem (CDC)\n"
648                     "8) Generic Endpoint Loopback (GENERIC)\n"
649                     "x) Return to previous menu\n");
650
651                 switch (retval) {
652                 case 0:
653                         break;
654                 case 1:
655                         show_device_audio_select(level + 1);
656                         break;
657                 case 2:
658                         show_device_msc_select(level + 1);
659                         break;
660                 case 3:
661                         show_device_ethernet_select(level + 1);
662                         break;
663                 case 4:
664                         show_device_keyboard_select(level + 1);
665                         break;
666                 case 5:
667                         show_device_mouse_select(level + 1);
668                         break;
669                 case 6:
670                         show_device_mtp_select(level + 1);
671                         break;
672                 case 7:
673                         show_device_modem_select(level + 1);
674                         break;
675                 case 8:
676                         show_device_generic_select(level + 1);
677                         break;
678                 default:
679                         return;
680                 }
681         }
682 }
683
684 static void
685 show_host_select(uint8_t level)
686 {
687         int force_fs = 0;
688         int error;
689         uint32_t duration = 60;
690
691         uint16_t dev_vid = 0;
692         uint16_t dev_pid = 0;
693         uint8_t retval;
694
695         while (1) {
696
697                 error = sysctlbyname("hw.usb.ehci.no_hs", NULL, NULL,
698                     &force_fs, sizeof(force_fs));
699
700                 if (error != 0) {
701                         printf("WARNING: Could not set non-FS mode "
702                             "to %d (error=%d)\n", force_fs, errno);
703                 }
704                 retval = usb_ts_show_menu(level, "Select Host Mode Test (via LibUSB)",
705                     " 1) Select USB device (VID=0x%04x, PID=0x%04x)\n"
706                     " 2) Manually enter USB vendor and product ID\n"
707                     " 3) Force FULL speed operation: <%s>\n"
708                     " 4) Mass Storage (UMASS)\n"
709                     " 5) Modem (UMODEM)\n"
710                     "10) Start String Descriptor Test\n"
711                     "11) Start Port Reset Test\n"
712                     "12) Start Set Config Test\n"
713                     "13) Start Get Descriptor Test\n"
714                     "14) Start Suspend and Resume Test\n"
715                     "15) Start Set and Clear Endpoint Stall Test\n"
716                     "16) Start Set Alternate Interface Setting Test\n"
717                     "17) Start Invalid Control Request Test\n"
718                     "30) Duration: <%d> seconds\n"
719                     "x) Return to previous menu\n",
720                     dev_vid, dev_pid,
721                     force_fs ? "YES" : "NO",
722                     (int)duration);
723
724                 switch (retval) {
725                 case 0:
726                         break;
727                 case 1:
728                         show_host_device_selection(level + 1, &dev_vid, &dev_pid);
729                         break;
730                 case 2:
731                         dev_vid = get_integer() & 0xFFFF;
732                         dev_pid = get_integer() & 0xFFFF;
733                         break;
734                 case 3:
735                         force_fs ^= 1;
736                         break;
737                 case 4:
738                         show_host_msc_test(level + 1, dev_vid, dev_pid, duration);
739                         break;
740                 case 5:
741                         show_host_modem_test(level + 1, dev_vid, dev_pid, duration);
742                         break;
743                 case 10:
744                         usb_get_string_desc_test(dev_vid, dev_pid);
745                         break;
746                 case 11:
747                         usb_port_reset_test(dev_vid, dev_pid, duration);
748                         break;
749                 case 12:
750                         usb_set_config_test(dev_vid, dev_pid, duration);
751                         break;
752                 case 13:
753                         usb_get_descriptor_test(dev_vid, dev_pid, duration);
754                         break;
755                 case 14:
756                         usb_suspend_resume_test(dev_vid, dev_pid, duration);
757                         break;
758                 case 15:
759                         usb_set_and_clear_stall_test(dev_vid, dev_pid);
760                         break;
761                 case 16:
762                         usb_set_alt_interface_test(dev_vid, dev_pid);
763                         break;
764                 case 17:
765                         usb_control_ep_error_test(dev_vid, dev_pid);
766                         break;
767                 case 30:
768                         duration = get_integer();
769                         break;
770                 default:
771                         return;
772                 }
773         }
774 }
775
776 static void
777 show_mode_select(uint8_t level)
778 {
779         uint8_t retval;
780
781         while (1) {
782
783                 retval = usb_ts_show_menu(level, "Select Computer Mode",
784                     "1) This computer is Running the Device Side\n"
785                     "2) This computer is Running the Host Side\n"
786                     "x) Return to previous menu\n");
787
788                 switch (retval) {
789                 case 0:
790                         break;
791                 case 1:
792                         show_device_select(level + 1);
793                         break;
794                 case 2:
795                         show_host_select(level + 1);
796                         break;
797                 default:
798                         return;
799                 }
800         }
801 }
802
803 int
804 main(int argc, char **argv)
805 {
806         show_mode_select(1);
807
808         return (0);
809 }