dsynth - Don't double-add ports-mgmt/pkg
[dragonfly.git] / tools / tools / usbtest / usb_modem_test.c
1 /* $FreeBSD: head/tools/tools/usbtest/usb_modem_test.c 254241 2013-08-12 09:15:33Z hselasky $ */
2 /*-
3  * Copyright (c) 2007-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 <stdlib.h>
30 #include <err.h>
31 #include <string.h>
32 #include <errno.h>
33 #include <unistd.h>
34
35 #include <sys/sysctl.h>
36 #include <sys/time.h>
37
38 #include <libusb20.h>
39 #include <libusb20_desc.h>
40
41 #include <bus/u4b/usb_endian.h>
42 #include <bus/u4b/usb.h>
43 #include <bus/u4b/usb_cdc.h>
44
45 #include "usbtest.h"
46
47 static struct modem {
48         struct libusb20_transfer *xfer_in;
49         struct libusb20_transfer *xfer_out;
50         struct libusb20_device *usb_dev;
51
52         struct bps rx_bytes;
53         struct bps tx_bytes;
54         uint32_t c0;
55         uint32_t c1;
56         uint32_t out_state;
57         uint32_t in_last;
58         uint32_t in_synced;
59         uint32_t duration;
60         uint32_t errors;
61
62         uint8_t use_vendor_specific;
63         uint8_t loop_data;
64         uint8_t modem_at_mode;
65         uint8_t data_stress_test;
66         uint8_t control_ep_test;
67         uint8_t usb_iface;
68         uint8_t random_tx_length;
69         uint8_t random_tx_delay;
70
71 }       modem;
72
73 static void
74 set_defaults(struct modem *p)
75 {
76         memset(p, 0, sizeof(*p));
77
78         p->data_stress_test = 1;
79         p->control_ep_test = 1;
80         p->duration = 60;               /* seconds */
81 }
82
83 void
84 do_bps(const char *desc, struct bps *bps, uint32_t len)
85 {
86         bps->bytes += len;
87 }
88
89 static void
90 modem_out_state(uint8_t *buf)
91 {
92         if (modem.modem_at_mode) {
93                 switch (modem.out_state & 3) {
94                 case 0:
95                         *buf = 'A';
96                         break;
97                 case 1:
98                         *buf = 'T';
99                         break;
100                 case 2:
101                         *buf = '\r';
102                         break;
103                 default:
104                         *buf = '\n';
105                         modem.c0++;
106                         break;
107                 }
108                 modem.out_state++;
109         } else {
110                 *buf = modem.out_state;
111                 modem.out_state++;
112                 modem.out_state %= 255;
113         }
114 }
115
116 static void
117 modem_in_state(uint8_t buf, uint32_t counter)
118 {
119         if ((modem.in_last == 'O') && (buf == 'K')) {
120                 modem.c1++;
121                 modem.in_last = buf;
122         } else if (buf == modem.in_last) {
123                 modem.c1++;
124                 modem.in_last++;
125                 modem.in_last %= 255;
126                 if (modem.in_synced == 0) {
127                         if (modem.errors < 64) {
128                                 printf("Got sync\n");
129                         }
130                         modem.in_synced = 1;
131                 }
132         } else {
133                 if (modem.in_synced) {
134                         if (modem.errors < 64) {
135                                 printf("Lost sync @ %d, 0x%02x != 0x%02x\n",
136                                     counter % 512, buf, modem.in_last);
137                         }
138                         modem.in_synced = 0;
139                         modem.errors++;
140                 }
141                 modem.in_last = buf;
142                 modem.in_last++;
143                 modem.in_last %= 255;
144         }
145 }
146
147 static void
148 modem_write(uint8_t *buf, uint32_t len)
149 {
150         uint32_t n;
151
152         for (n = 0; n != len; n++) {
153                 modem_out_state(buf + n);
154         }
155
156         do_bps("transmitted", &modem.tx_bytes, len);
157 }
158
159 static void
160 modem_read(uint8_t *buf, uint32_t len)
161 {
162         uint32_t n;
163
164         for (n = 0; n != len; n++) {
165                 modem_in_state(buf[n], n);
166         }
167
168         do_bps("received", &modem.rx_bytes, len);
169 }
170
171 static void
172 usb_modem_control_ep_test(struct modem *p, uint32_t duration, uint8_t flag)
173 {
174         struct timeval sub_tv;
175         struct timeval ref_tv;
176         struct timeval res_tv;
177         struct LIBUSB20_CONTROL_SETUP_DECODED setup;
178         struct usb_cdc_abstract_state ast;
179         struct usb_cdc_line_state ls;
180         uint16_t feature = UCDC_ABSTRACT_STATE;
181         uint16_t state = UCDC_DATA_MULTIPLEXED;
182         uint8_t iface_no;
183         uint8_t buf[4];
184         int id = 0;
185         int iter = 0;
186
187         time_t last_sec;
188
189         iface_no = p->usb_iface - 1;
190
191         gettimeofday(&ref_tv, 0);
192
193         last_sec = ref_tv.tv_sec;
194
195         printf("\nTest=%d\n", (int)flag);
196
197         while (1) {
198
199                 gettimeofday(&sub_tv, 0);
200
201                 if (last_sec != sub_tv.tv_sec) {
202
203                         printf("STATUS: ID=%u, COUNT=%u tests/sec ERR=%u\n",
204                             (int)id,
205                             (int)iter,
206                             (int)p->errors);
207
208                         fflush(stdout);
209
210                         last_sec = sub_tv.tv_sec;
211
212                         id++;
213
214                         iter = 0;
215                 }
216                 timersub(&sub_tv, &ref_tv, &res_tv);
217
218                 if ((res_tv.tv_sec < 0) || (res_tv.tv_sec >= (int)duration))
219                         break;
220
221                 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
222
223                 if (flag & 1) {
224                         setup.bmRequestType = UT_READ_CLASS_INTERFACE;
225                         setup.bRequest = 0x03;
226                         setup.wValue = 0x0001;
227                         setup.wIndex = iface_no;
228                         setup.wLength = 0x0002;
229
230                         if (libusb20_dev_request_sync(p->usb_dev, &setup, buf, NULL, 250, 0)) {
231                                 p->errors++;
232                         }
233                 }
234                 if (flag & 2) {
235                         setup.bmRequestType = UT_WRITE_CLASS_INTERFACE;
236                         setup.bRequest = UCDC_SET_COMM_FEATURE;
237                         setup.wValue = feature;
238                         setup.wIndex = iface_no;
239                         setup.wLength = UCDC_ABSTRACT_STATE_LENGTH;
240                         USETW(ast.wState, state);
241
242                         if (libusb20_dev_request_sync(p->usb_dev, &setup, &ast, NULL, 250, 0)) {
243                                 p->errors++;
244                         }
245                 }
246                 if (flag & 4) {
247                         USETDW(ls.dwDTERate, 115200);
248                         ls.bCharFormat = UCDC_STOP_BIT_1;
249                         ls.bParityType = UCDC_PARITY_NONE;
250                         ls.bDataBits = 8;
251
252                         setup.bmRequestType = UT_WRITE_CLASS_INTERFACE;
253                         setup.bRequest = UCDC_SET_LINE_CODING;
254                         setup.wValue = 0;
255                         setup.wIndex = iface_no;
256                         setup.wLength = sizeof(ls);
257
258                         if (libusb20_dev_request_sync(p->usb_dev, &setup, &ls, NULL, 250, 0)) {
259                                 p->errors++;
260                         }
261                 }
262                 iter++;
263         }
264
265         printf("\nModem control endpoint test done!\n");
266 }
267
268 static void
269 usb_modem_data_stress_test(struct modem *p, uint32_t duration)
270 {
271         struct timeval sub_tv;
272         struct timeval ref_tv;
273         struct timeval res_tv;
274
275         time_t last_sec;
276
277         uint8_t in_pending = 0;
278         uint8_t in_ready = 0;
279         uint8_t out_pending = 0;
280
281         uint32_t id = 0;
282
283         uint32_t in_max;
284         uint32_t out_max;
285         uint32_t io_max;
286
287         uint8_t *in_buffer = NULL;
288         uint8_t *out_buffer = NULL;
289
290         gettimeofday(&ref_tv, 0);
291
292         last_sec = ref_tv.tv_sec;
293
294         printf("\n");
295
296         in_max = libusb20_tr_get_max_total_length(p->xfer_in);
297         out_max = libusb20_tr_get_max_total_length(p->xfer_out);
298
299         /* get the smallest buffer size and use that */
300         io_max = (in_max < out_max) ? in_max : out_max;
301
302         if (in_max != out_max)
303                 printf("WARNING: Buffer sizes are un-equal: %u vs %u\n", in_max, out_max);
304
305         in_buffer = malloc(io_max);
306         if (in_buffer == NULL)
307                 goto fail;
308
309         out_buffer = malloc(io_max);
310         if (out_buffer == NULL)
311                 goto fail;
312
313         while (1) {
314
315                 gettimeofday(&sub_tv, 0);
316
317                 if (last_sec != sub_tv.tv_sec) {
318
319                         printf("STATUS: ID=%u, RX=%u bytes/sec, TX=%u bytes/sec, ERR=%d\n",
320                             (int)id,
321                             (int)p->rx_bytes.bytes,
322                             (int)p->tx_bytes.bytes,
323                             (int)p->errors);
324
325                         p->rx_bytes.bytes = 0;
326                         p->tx_bytes.bytes = 0;
327
328                         fflush(stdout);
329
330                         last_sec = sub_tv.tv_sec;
331
332                         id++;
333                 }
334                 timersub(&sub_tv, &ref_tv, &res_tv);
335
336                 if ((res_tv.tv_sec < 0) || (res_tv.tv_sec >= (int)duration))
337                         break;
338
339                 libusb20_dev_process(p->usb_dev);
340
341                 if (!libusb20_tr_pending(p->xfer_in)) {
342                         if (in_pending) {
343                                 if (libusb20_tr_get_status(p->xfer_in) == 0) {
344                                         modem_read(in_buffer, libusb20_tr_get_length(p->xfer_in, 0));
345                                 } else {
346                                         p->errors++;
347                                         usleep(10000);
348                                 }
349                                 in_pending = 0;
350                                 in_ready = 1;
351                         }
352                         if (p->loop_data == 0) {
353                                 libusb20_tr_setup_bulk(p->xfer_in, in_buffer, io_max, 0);
354                                 libusb20_tr_start(p->xfer_in);
355                                 in_pending = 1;
356                                 in_ready = 0;
357                         }
358                 }
359                 if (!libusb20_tr_pending(p->xfer_out)) {
360
361                         uint32_t len;
362                         uint32_t dly;
363
364                         if (out_pending) {
365                                 if (libusb20_tr_get_status(p->xfer_out) != 0) {
366                                         p->errors++;
367                                         usleep(10000);
368                                 }
369                         }
370                         if (p->random_tx_length) {
371                                 len = ((uint32_t)usb_ts_rand_noise()) % ((uint32_t)io_max);
372                         } else {
373                                 len = io_max;
374                         }
375
376                         if (p->random_tx_delay) {
377                                 dly = ((uint32_t)usb_ts_rand_noise()) % 16000U;
378                         } else {
379                                 dly = 0;
380                         }
381
382                         if (p->loop_data != 0) {
383                                 if (in_ready != 0) {
384                                         len = libusb20_tr_get_length(p->xfer_in, 0);
385                                         memcpy(out_buffer, in_buffer, len);
386                                         in_ready = 0;
387                                 } else {
388                                         len = io_max + 1;
389                                 }
390                                 if (!libusb20_tr_pending(p->xfer_in)) {
391                                         libusb20_tr_setup_bulk(p->xfer_in, in_buffer, io_max, 0);
392                                         libusb20_tr_start(p->xfer_in);
393                                         in_pending = 1;
394                                 }
395                         } else {
396                                 modem_write(out_buffer, len);
397                         }
398
399                         if (len <= io_max) {
400                                 libusb20_tr_setup_bulk(p->xfer_out, out_buffer, len, 0);
401
402                                 if (dly != 0)
403                                         usleep(dly);
404
405                                 libusb20_tr_start(p->xfer_out);
406
407                                 out_pending = 1;
408                         }
409                 }
410                 libusb20_dev_wait_process(p->usb_dev, 500);
411
412                 if (libusb20_dev_check_connected(p->usb_dev) != 0) {
413                         printf("Device disconnected\n");
414                         break;
415                 }
416         }
417
418         libusb20_tr_stop(p->xfer_in);
419         libusb20_tr_stop(p->xfer_out);
420
421         printf("\nData stress test done!\n");
422
423 fail:
424         if (in_buffer)
425                 free(in_buffer);
426         if (out_buffer)
427                 free(out_buffer);
428 }
429
430 static void
431 exec_host_modem_test(struct modem *p, uint16_t vid, uint16_t pid)
432 {
433         struct libusb20_device *pdev;
434
435         uint8_t ntest = 0;
436         uint8_t x;
437         uint8_t in_ep;
438         uint8_t out_ep;
439         uint8_t iface;
440
441         int error;
442
443         pdev = find_usb_device(vid, pid);
444         if (pdev == NULL) {
445                 printf("USB device not found\n");
446                 return;
447         }
448
449         if (p->use_vendor_specific)
450                 find_usb_endpoints(pdev, 255, 255, 255, 0, &iface, &in_ep, &out_ep, 0);
451         else
452                 find_usb_endpoints(pdev, 2, 2, 1, 0, &iface, &in_ep, &out_ep, 1);
453
454         if ((in_ep == 0) || (out_ep == 0)) {
455                 printf("Could not find USB endpoints\n");
456                 libusb20_dev_free(pdev);
457                 return;
458         }
459         printf("Attaching to: %s @ iface %d\n",
460             libusb20_dev_get_desc(pdev), iface);
461
462         if (libusb20_dev_open(pdev, 2)) {
463                 printf("Could not open USB device\n");
464                 libusb20_dev_free(pdev);
465                 return;
466         }
467         if (libusb20_dev_detach_kernel_driver(pdev, iface)) {
468                 printf("WARNING: Could not detach kernel driver\n");
469         }
470         p->xfer_in = libusb20_tr_get_pointer(pdev, 0);
471         error = libusb20_tr_open(p->xfer_in, 65536 / 4, 1, in_ep);
472         if (error) {
473                 printf("Could not open USB endpoint %d\n", in_ep);
474                 libusb20_dev_free(pdev);
475                 return;
476         }
477         p->xfer_out = libusb20_tr_get_pointer(pdev, 1);
478         error = libusb20_tr_open(p->xfer_out, 65536 / 4, 1, out_ep);
479         if (error) {
480                 printf("Could not open USB endpoint %d\n", out_ep);
481                 libusb20_dev_free(pdev);
482                 return;
483         }
484         p->usb_dev = pdev;
485         p->usb_iface = iface;
486         p->errors = 0;
487
488         if (p->control_ep_test)
489                 ntest += 7;
490
491         if (p->data_stress_test)
492                 ntest += 1;
493
494         if (ntest == 0) {
495                 printf("No tests selected\n");
496         } else {
497
498                 if (p->control_ep_test) {
499                         for (x = 1; x != 8; x++) {
500                                 usb_modem_control_ep_test(p,
501                                     (p->duration + ntest - 1) / ntest, x);
502                         }
503                 }
504                 if (p->data_stress_test) {
505                         usb_modem_data_stress_test(p,
506                             (p->duration + ntest - 1) / ntest);
507                 }
508         }
509
510         printf("\nDone\n");
511
512         libusb20_dev_free(pdev);
513 }
514
515 void
516 show_host_modem_test(uint8_t level, uint16_t vid, uint16_t pid, uint32_t duration)
517 {
518         uint8_t retval;
519
520         set_defaults(&modem);
521
522         modem.duration = duration;
523
524         while (1) {
525
526                 retval = usb_ts_show_menu(level, "Modem Test Parameters",
527                     " 1) Execute Data Stress Test: <%s>\n"
528                     " 2) Execute Modem Control Endpoint Test: <%s>\n"
529                     " 3) Use random transmit length: <%s>\n"
530                     " 4) Use random transmit delay: <%s> ms\n"
531                     " 5) Use vendor specific interface: <%s>\n"
532                     "10) Loop data: <%s>\n"
533                     "13) Set test duration: <%d> seconds\n"
534                     "20) Reset parameters\n"
535                     "30) Start test (VID=0x%04x, PID=0x%04x)\n"
536                     "40) Select another device\n"
537                     " x) Return to previous menu \n",
538                     (modem.data_stress_test ? "YES" : "NO"),
539                     (modem.control_ep_test ? "YES" : "NO"),
540                     (modem.random_tx_length ? "YES" : "NO"),
541                     (modem.random_tx_delay ? "16" : "0"),
542                     (modem.use_vendor_specific ? "YES" : "NO"),
543                     (modem.loop_data ? "YES" : "NO"),
544                     (int)(modem.duration),
545                     (int)vid, (int)pid);
546
547                 switch (retval) {
548                 case 0:
549                         break;
550                 case 1:
551                         modem.data_stress_test ^= 1;
552                         break;
553                 case 2:
554                         modem.control_ep_test ^= 1;
555                         break;
556                 case 3:
557                         modem.random_tx_length ^= 1;
558                         break;
559                 case 4:
560                         modem.random_tx_delay ^= 1;
561                         break;
562                 case 5:
563                         modem.use_vendor_specific ^= 1;
564                         modem.control_ep_test = 0;
565                         break;
566                 case 10:
567                         modem.loop_data ^= 1;
568                         break;
569                 case 13:
570                         modem.duration = get_integer();
571                         break;
572                 case 20:
573                         set_defaults(&modem);
574                         break;
575                 case 30:
576                         exec_host_modem_test(&modem, vid, pid);
577                         break;
578                 case 40:
579                         show_host_device_selection(level + 1, &vid, &pid);
580                         break;
581                 default:
582                         return;
583                 }
584         }
585 }