1 |
786 |
skrzyp |
/*{{{ Banner */
|
2 |
|
|
|
3 |
|
|
//=================================================================
|
4 |
|
|
//
|
5 |
|
|
// host.c
|
6 |
|
|
//
|
7 |
|
|
// USB testing - host-side
|
8 |
|
|
//
|
9 |
|
|
//==========================================================================
|
10 |
|
|
// ####ECOSGPLCOPYRIGHTBEGIN####
|
11 |
|
|
// -------------------------------------------
|
12 |
|
|
// This file is part of eCos, the Embedded Configurable Operating System.
|
13 |
|
|
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005 Free Software Foundation, Inc.
|
14 |
|
|
//
|
15 |
|
|
// eCos is free software; you can redistribute it and/or modify it under
|
16 |
|
|
// the terms of the GNU General Public License as published by the Free
|
17 |
|
|
// Software Foundation; either version 2 or (at your option) any later
|
18 |
|
|
// version.
|
19 |
|
|
//
|
20 |
|
|
// eCos is distributed in the hope that it will be useful, but WITHOUT
|
21 |
|
|
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
22 |
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
23 |
|
|
// for more details.
|
24 |
|
|
//
|
25 |
|
|
// You should have received a copy of the GNU General Public License
|
26 |
|
|
// along with eCos; if not, write to the Free Software Foundation, Inc.,
|
27 |
|
|
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
28 |
|
|
//
|
29 |
|
|
// As a special exception, if other files instantiate templates or use
|
30 |
|
|
// macros or inline functions from this file, or you compile this file
|
31 |
|
|
// and link it with other works to produce a work based on this file,
|
32 |
|
|
// this file does not by itself cause the resulting work to be covered by
|
33 |
|
|
// the GNU General Public License. However the source code for this file
|
34 |
|
|
// must still be made available in accordance with section (3) of the GNU
|
35 |
|
|
// General Public License v2.
|
36 |
|
|
//
|
37 |
|
|
// This exception does not invalidate any other reasons why a work based
|
38 |
|
|
// on this file might be covered by the GNU General Public License.
|
39 |
|
|
// -------------------------------------------
|
40 |
|
|
// ####ECOSGPLCOPYRIGHTEND####
|
41 |
|
|
//==========================================================================
|
42 |
|
|
//#####DESCRIPTIONBEGIN####
|
43 |
|
|
//
|
44 |
|
|
// Author(s): bartv
|
45 |
|
|
// Date: 2001-07-04
|
46 |
|
|
//####DESCRIPTIONEND####
|
47 |
|
|
//==========================================================================
|
48 |
|
|
|
49 |
|
|
// The overall architecture is as follows.
|
50 |
|
|
//
|
51 |
|
|
// The target hardware runs a special application which provides a
|
52 |
|
|
// particular type of USB application, "Red Hat eCos USB testing".
|
53 |
|
|
// This will not be recognised by any device driver, so the Linux
|
54 |
|
|
// kernel will pretty much ignore the device (other host OS's are not
|
55 |
|
|
// considered at this time).
|
56 |
|
|
//
|
57 |
|
|
// This program is the only supported way to interact with that service.
|
58 |
|
|
// It acts as an extended Tcl interpreter, providing a number of new
|
59 |
|
|
// Tcl commands for interacting with the target. All test cases can
|
60 |
|
|
// then be written as Tcl scripts which invoke a series of these commands.
|
61 |
|
|
// These Tcl commands operate essentially though the LINUX usb devfs
|
62 |
|
|
// service which allows ordinary application code to perform USB operations
|
63 |
|
|
// via ioctl()'s.
|
64 |
|
|
|
65 |
|
|
/*}}}*/
|
66 |
|
|
/*{{{ #include's */
|
67 |
|
|
|
68 |
|
|
// To get the desired version of strerror_r()
|
69 |
|
|
#define _GNU_SOURCE 1
|
70 |
|
|
#include <stdio.h>
|
71 |
|
|
#include <stdlib.h>
|
72 |
|
|
#include <string.h>
|
73 |
|
|
#include <ctype.h>
|
74 |
|
|
#include <limits.h>
|
75 |
|
|
#include <errno.h>
|
76 |
|
|
#include <sys/types.h>
|
77 |
|
|
#include <sys/stat.h>
|
78 |
|
|
#include <unistd.h>
|
79 |
|
|
#include <fcntl.h>
|
80 |
|
|
#include <sys/ioctl.h>
|
81 |
|
|
#include <time.h>
|
82 |
|
|
#include <pthread.h>
|
83 |
|
|
#include <semaphore.h>
|
84 |
|
|
// Avoid compatibility problems with Tcl 8.4 vs. earlier
|
85 |
|
|
#define USE_NON_CONST
|
86 |
|
|
#include <tcl.h>
|
87 |
|
|
#include <linux/usb/ch9.h>
|
88 |
|
|
#include <linux/usbdevice_fs.h>
|
89 |
|
|
#include "../tests/protocol.h"
|
90 |
|
|
#include "config.h"
|
91 |
|
|
|
92 |
|
|
/*}}}*/
|
93 |
|
|
|
94 |
|
|
/*{{{ Backwards compatibility */
|
95 |
|
|
|
96 |
|
|
// The header file <linux/usbdevice_fs.h> has changed in an incompatible
|
97 |
|
|
// way. This is detected by autoconf
|
98 |
|
|
#ifndef CYGBLD_USE_NEW_FIELD_NAMES
|
99 |
|
|
# define bRequestType requesttype
|
100 |
|
|
# define bRequest request
|
101 |
|
|
# define wValue value
|
102 |
|
|
# define wIndex index
|
103 |
|
|
# define wLength length
|
104 |
|
|
#endif
|
105 |
|
|
|
106 |
|
|
/*}}}*/
|
107 |
|
|
/*{{{ Statics */
|
108 |
|
|
|
109 |
|
|
// ----------------------------------------------------------------------------
|
110 |
|
|
// Statics.
|
111 |
|
|
|
112 |
|
|
// Has the current batch of tests actually terminated? This flag is
|
113 |
|
|
// checked by the various test handlers at appropriate intervals, and
|
114 |
|
|
// helps to handle the case where one of the side has terminated early
|
115 |
|
|
// because an error has been detected.
|
116 |
|
|
static int current_tests_terminated = 0;
|
117 |
|
|
|
118 |
|
|
// The next local thread to be allocated for testing. This variable can also
|
119 |
|
|
// be used to find out how many threads are involved in the current test.
|
120 |
|
|
// This counter should always be reset to 0 at the end of every test run.
|
121 |
|
|
static int local_thread_count = 0;
|
122 |
|
|
|
123 |
|
|
// A similar counter for remote threads.
|
124 |
|
|
static int remote_thread_count = 0;
|
125 |
|
|
|
126 |
|
|
// A file handle for manipulating the USB device at a low level
|
127 |
|
|
static int usb_master_fd = -1;
|
128 |
|
|
|
129 |
|
|
/*}}}*/
|
130 |
|
|
/*{{{ Logging */
|
131 |
|
|
|
132 |
|
|
// ----------------------------------------------------------------------------
|
133 |
|
|
// The user can provide one or more -V/--verbose arguments to increase
|
134 |
|
|
// the amount of output generated.
|
135 |
|
|
|
136 |
|
|
static int verbose = 0;
|
137 |
|
|
|
138 |
|
|
#define VERBOSE(_level_, _format_, _args_...) \
|
139 |
|
|
do { \
|
140 |
|
|
if (verbose >= _level_) { \
|
141 |
|
|
printf(_format_, ## _args_); \
|
142 |
|
|
} \
|
143 |
|
|
} while (0);
|
144 |
|
|
|
145 |
|
|
/*}}}*/
|
146 |
|
|
/*{{{ Low-level USB access */
|
147 |
|
|
|
148 |
|
|
// ----------------------------------------------------------------------------
|
149 |
|
|
// Low-level access to a USB device.
|
150 |
|
|
//
|
151 |
|
|
// The various ioctl() calls require a file handle which corresponds to one
|
152 |
|
|
// of the /proc/bus/usb/<abc>/<def> entries. <abc> is a bus number,
|
153 |
|
|
// typically 001 or 001, and <def> is a device number on that bus,
|
154 |
|
|
// e.g. 003. Figuring out <abc> and <def> requires scanning
|
155 |
|
|
// /proc/bus/usb/devices, which is a somewhat complicated text file.
|
156 |
|
|
//
|
157 |
|
|
// This is all somewhat vulnerable to incompatible changes in the
|
158 |
|
|
// Linux kernel, specifically the implementation of the /proc/bus/usb.
|
159 |
|
|
// An alternative approach would be to write a new Linux device driver
|
160 |
|
|
// and interact with that, but that approach is vulnerable to any
|
161 |
|
|
// internal kernel API changes affecting USB device drivers.
|
162 |
|
|
|
163 |
|
|
// How to access USB devices from userland
|
164 |
|
|
#define USB_ROOT "/proc/bus/usb/"
|
165 |
|
|
|
166 |
|
|
// How to identify the eCos test case
|
167 |
|
|
#define PRODUCT_STRING "Red Hat eCos USB test"
|
168 |
|
|
|
169 |
|
|
// Scan through /proc/bus/usb/devices looking for an entry that
|
170 |
|
|
// matches what we are after, specifically a line
|
171 |
|
|
// S: Product=Red Hat eCos USB testcase
|
172 |
|
|
// The required information can then be obtained from the previous
|
173 |
|
|
// line:
|
174 |
|
|
// T: Bus=<abc> ... Dev#= <def> ...
|
175 |
|
|
//
|
176 |
|
|
// Of course the T: line is going to come first, so it is necessary
|
177 |
|
|
// to keep track of the current bus and device numbers.
|
178 |
|
|
//
|
179 |
|
|
// Note: this code is duplicated in usbchmod.c. Any changes here
|
180 |
|
|
// should be propagated. For now the routine is too small to warrant
|
181 |
|
|
// a separate source file.
|
182 |
|
|
|
183 |
|
|
static int
|
184 |
|
|
usb_scan_devices(int* bus, int* dev)
|
185 |
|
|
{
|
186 |
|
|
FILE* devs_file;
|
187 |
|
|
int current_bus = -1;
|
188 |
|
|
int current_dev = -1;
|
189 |
|
|
int ch;
|
190 |
|
|
|
191 |
|
|
*bus = -1;
|
192 |
|
|
*dev = -1;
|
193 |
|
|
|
194 |
|
|
VERBOSE(1, "Searching " USB_ROOT "devices for the eCos USB test code\n");
|
195 |
|
|
|
196 |
|
|
devs_file = fopen(USB_ROOT "devices", "r");
|
197 |
|
|
if (NULL == devs_file) {
|
198 |
|
|
fprintf(stderr, "usbhost: error, unable to access " USB_ROOT "devices\n");
|
199 |
|
|
return 0;
|
200 |
|
|
}
|
201 |
|
|
ch = getc(devs_file);
|
202 |
|
|
while (EOF != ch) {
|
203 |
|
|
if ('T' == ch) {
|
204 |
|
|
if (2 !=fscanf(devs_file, ": Bus=%d %*[^D\n]Dev#=%d", ¤t_bus, ¤t_dev)) {
|
205 |
|
|
current_bus = -1;
|
206 |
|
|
current_dev = -1;
|
207 |
|
|
}
|
208 |
|
|
} else if ('S' == ch) {
|
209 |
|
|
int start = 0, end = 0;
|
210 |
|
|
if (EOF != fscanf(devs_file, ": Product=%n" PRODUCT_STRING "%n", &start, &end)) {
|
211 |
|
|
if (start < end) {
|
212 |
|
|
*bus = current_bus;
|
213 |
|
|
*dev = current_dev;
|
214 |
|
|
break;
|
215 |
|
|
}
|
216 |
|
|
}
|
217 |
|
|
}
|
218 |
|
|
// Move to the end of the current line.
|
219 |
|
|
while ((EOF != ch) && ('\n' != ch)) {
|
220 |
|
|
ch = getc(devs_file);
|
221 |
|
|
}
|
222 |
|
|
if (EOF != ch) {
|
223 |
|
|
ch = getc(devs_file);
|
224 |
|
|
}
|
225 |
|
|
}
|
226 |
|
|
|
227 |
|
|
fclose(devs_file);
|
228 |
|
|
if ((-1 != *bus) && (-1 != *dev)) {
|
229 |
|
|
VERBOSE(1, "Found eCos USB test code on bus %d, device %d\n", *bus, *dev);
|
230 |
|
|
return 1;
|
231 |
|
|
}
|
232 |
|
|
fprintf(stderr, "usbhost: error, failed to find a USB device \"" PRODUCT_STRING "\"\n");
|
233 |
|
|
return 0;
|
234 |
|
|
}
|
235 |
|
|
|
236 |
|
|
// Actually open the USB device, allowing subsequent ioctl() operations.
|
237 |
|
|
//
|
238 |
|
|
// Typically /proc/bus/usb/... will not allow ordinary applications
|
239 |
|
|
// to perform ioctl()'s. Instead root privileges are required. To work
|
240 |
|
|
// around this there is a little utility usbchmod, installed suid,
|
241 |
|
|
// which can be used to get access to the raw device.
|
242 |
|
|
static int
|
243 |
|
|
usb_open_device(void)
|
244 |
|
|
{
|
245 |
|
|
char devname[_POSIX_PATH_MAX];
|
246 |
|
|
static int bus = -1;
|
247 |
|
|
static int dev = -1;
|
248 |
|
|
int result;
|
249 |
|
|
|
250 |
|
|
if ((-1 == bus) || (-1 == dev)) {
|
251 |
|
|
if (!usb_scan_devices(&bus, &dev)) {
|
252 |
|
|
return -1;
|
253 |
|
|
}
|
254 |
|
|
}
|
255 |
|
|
|
256 |
|
|
if (_POSIX_PATH_MAX == snprintf(devname, _POSIX_PATH_MAX, USB_ROOT "%03d/%03d", bus, dev)) {
|
257 |
|
|
fprintf(stderr, "usbhost: internal error, buffer overflow\n");
|
258 |
|
|
exit(EXIT_FAILURE);
|
259 |
|
|
}
|
260 |
|
|
|
261 |
|
|
VERBOSE(1, "Attempting to access USB target via %s\n", devname);
|
262 |
|
|
|
263 |
|
|
result = open(devname, O_RDWR);
|
264 |
|
|
if (-1 == result) {
|
265 |
|
|
// Check for access right problems. If so, try to work around them
|
266 |
|
|
// by invoking usbchmod. Always look for this in the install tree,
|
267 |
|
|
// since it is only that version which is likely to have been
|
268 |
|
|
// chown'ed and chmod'ed to be suid root.
|
269 |
|
|
if (EACCES == errno) {
|
270 |
|
|
char command_name[_POSIX_PATH_MAX];
|
271 |
|
|
|
272 |
|
|
VERBOSE(1, "Insufficient access to USB target, running usbchmod\n");
|
273 |
|
|
if (_POSIX_PATH_MAX == snprintf(command_name, _POSIX_PATH_MAX, "%s/usbchmod %d %d", USBAUXDIR, bus, dev)) {
|
274 |
|
|
fprintf(stderr, "usbhost: internal error, buffer overflow\n");
|
275 |
|
|
exit(EXIT_FAILURE);
|
276 |
|
|
}
|
277 |
|
|
(void) system(command_name);
|
278 |
|
|
result = open(devname, O_RDWR);
|
279 |
|
|
}
|
280 |
|
|
}
|
281 |
|
|
if (-1 == result) {
|
282 |
|
|
fprintf(stderr, "usbhost: error, failed to open \"%s\", errno %d\n", devname, errno);
|
283 |
|
|
exit(EXIT_FAILURE);
|
284 |
|
|
}
|
285 |
|
|
|
286 |
|
|
VERBOSE(1, "USB device now accessible via file descriptor %d\n", result);
|
287 |
|
|
|
288 |
|
|
// Also perform a set-configuration call, to avoid warnings from
|
289 |
|
|
// the Linux kernel. Target-side testing is always configuration 1
|
290 |
|
|
// because only a single configuration is supported.
|
291 |
|
|
(void) ioctl(result, USBDEVFS_SETCONFIGURATION, 1);
|
292 |
|
|
return result;
|
293 |
|
|
}
|
294 |
|
|
|
295 |
|
|
// Exchange a control message with the host. The return value should
|
296 |
|
|
// be 0, or a small positive number indicating the actual number of
|
297 |
|
|
// bytes received which may be less than requested.
|
298 |
|
|
//
|
299 |
|
|
// There appear to be problems with some hosts, manifesting itself as
|
300 |
|
|
// an inability to send control messages that involve additional data
|
301 |
|
|
// from host->target. These problems are not yet well-understood. For
|
302 |
|
|
// now the workaround is to send multiple packets, each with up to
|
303 |
|
|
// four bytes encoded in the index and length fields.
|
304 |
|
|
static int
|
305 |
|
|
usb_control_message(int fd, int request_type, int request, int value, int index, int length, void* data)
|
306 |
|
|
{
|
307 |
|
|
struct usbdevfs_ctrltransfer transfer;
|
308 |
|
|
int result = 0;
|
309 |
|
|
|
310 |
|
|
VERBOSE(3, "usb_control_message, request %02x, len %d\n", request, length);
|
311 |
|
|
|
312 |
|
|
if (length > USBTEST_MAX_CONTROL_DATA) {
|
313 |
|
|
fprintf(stderr, "usbhost: internal error, control message involves too much data.\n");
|
314 |
|
|
exit(EXIT_FAILURE);
|
315 |
|
|
}
|
316 |
|
|
|
317 |
|
|
#if 1
|
318 |
|
|
// Workaround - send additional data in the index and length fields.
|
319 |
|
|
if ((length > 0) && (USB_DIR_OUT == (USB_ENDPOINT_DIR_MASK & request_type))) {
|
320 |
|
|
int i;
|
321 |
|
|
unsigned char* buf = (unsigned char*) data;
|
322 |
|
|
|
323 |
|
|
for (i = 0; i < length; i+= 4) {
|
324 |
|
|
int this_len = length - 1;
|
325 |
|
|
int ioctl_result;
|
326 |
|
|
|
327 |
|
|
transfer.bRequestType = USB_TYPE_CLASS | USB_RECIP_DEVICE;
|
328 |
|
|
if (this_len > 4) {
|
329 |
|
|
this_len = 4;
|
330 |
|
|
}
|
331 |
|
|
switch (this_len) {
|
332 |
|
|
case 1: transfer.bRequest = USBTEST_CONTROL_DATA1; break;
|
333 |
|
|
case 2: transfer.bRequest = USBTEST_CONTROL_DATA2; break;
|
334 |
|
|
case 3: transfer.bRequest = USBTEST_CONTROL_DATA3; break;
|
335 |
|
|
case 4: transfer.bRequest = USBTEST_CONTROL_DATA4; break;
|
336 |
|
|
default:
|
337 |
|
|
fprintf(stderr, "usbhost: internal error, confusion about transfer length.\n");
|
338 |
|
|
exit(EXIT_FAILURE);
|
339 |
|
|
}
|
340 |
|
|
transfer.wValue = (buf[i] << 8) | buf[i+1]; // Possible read beyond end of buffer,
|
341 |
|
|
transfer.wIndex = (buf[i+2] << 8) | buf[i+3]; // but not worth worrying about.
|
342 |
|
|
transfer.wLength = 0;
|
343 |
|
|
transfer.timeout = 10 * 1000; // ten seconds, the target should always accept data faster than this.
|
344 |
|
|
transfer.data = NULL;
|
345 |
|
|
|
346 |
|
|
// This is too strict, deciding what to do about errors should be
|
347 |
|
|
// handled by higher-level code. However it will do for now.
|
348 |
|
|
ioctl_result = ioctl(fd, USBDEVFS_CONTROL, &transfer);
|
349 |
|
|
if (0 != ioctl_result) {
|
350 |
|
|
fprintf(stderr, "usbhost: error, failed to send control message (data) to target.\n");
|
351 |
|
|
exit(EXIT_FAILURE);
|
352 |
|
|
}
|
353 |
|
|
}
|
354 |
|
|
// There is no more data to be transferred.
|
355 |
|
|
length = 0;
|
356 |
|
|
}
|
357 |
|
|
#endif
|
358 |
|
|
transfer.bRequestType = request_type;
|
359 |
|
|
transfer.bRequest = request;
|
360 |
|
|
transfer.wValue = value;
|
361 |
|
|
transfer.wIndex = index;
|
362 |
|
|
transfer.wLength = length;
|
363 |
|
|
transfer.timeout = 10000;
|
364 |
|
|
transfer.data = data;
|
365 |
|
|
|
366 |
|
|
result = ioctl(fd, USBDEVFS_CONTROL, &transfer);
|
367 |
|
|
return result;
|
368 |
|
|
}
|
369 |
|
|
|
370 |
|
|
// A variant of the above which can be called when the target should always respond
|
371 |
|
|
// correctly. This can be used for class control messages.
|
372 |
|
|
static int
|
373 |
|
|
usb_reliable_control_message(int fd, int request_type, int request, int value, int index, int length, void* data)
|
374 |
|
|
{
|
375 |
|
|
int result = usb_control_message(fd, request_type, request, value, index, length, data);
|
376 |
|
|
if (-1 == result) {
|
377 |
|
|
fprintf(stderr, "usbhost: error, failed to send control message %02x to target.\n", request);
|
378 |
|
|
fprintf(stderr, " : errno %d (%s)\n", errno, strerror(errno));
|
379 |
|
|
exit(EXIT_FAILURE);
|
380 |
|
|
}
|
381 |
|
|
return result;
|
382 |
|
|
}
|
383 |
|
|
|
384 |
|
|
|
385 |
|
|
// Either send or receive a single bulk message. The top bit of the endpoint
|
386 |
|
|
// number indicates the direction.
|
387 |
|
|
static int
|
388 |
|
|
usb_bulk_message(int fd, int endpoint, unsigned char* buffer, int length)
|
389 |
|
|
{
|
390 |
|
|
struct usbdevfs_bulktransfer transfer;
|
391 |
|
|
int result;
|
392 |
|
|
|
393 |
|
|
transfer.ep = endpoint;
|
394 |
|
|
transfer.len = length;
|
395 |
|
|
transfer.timeout = 60 * 60 * 1000;
|
396 |
|
|
// An hour. These operations should not time out because that
|
397 |
|
|
// leaves the system in a confused state. Instead there is
|
398 |
|
|
// higher-level recovery code that should ensure the operation
|
399 |
|
|
// really does complete, and the return value here is used
|
400 |
|
|
// by the calling code to determine whether the operation
|
401 |
|
|
// was successful or whether there was an error and the recovery
|
402 |
|
|
// code was invoked.
|
403 |
|
|
transfer.data = buffer;
|
404 |
|
|
errno = 0;
|
405 |
|
|
result = ioctl(fd, USBDEVFS_BULK, &transfer);
|
406 |
|
|
return result;
|
407 |
|
|
}
|
408 |
|
|
|
409 |
|
|
|
410 |
|
|
// Synchronise with the target. This can be used after the host has sent a request that
|
411 |
|
|
// may take a bit of time, e.g. it may involve waking up a thread. The host will send
|
412 |
|
|
// synch requests at regular intervals, until the target is ready.
|
413 |
|
|
//
|
414 |
|
|
// The limit argument can be used to avoid locking up. -1 means loop forever, otherwise
|
415 |
|
|
// it means that many iterations of 100ms apiece.
|
416 |
|
|
static int
|
417 |
|
|
usb_sync(int fd, int limit)
|
418 |
|
|
{
|
419 |
|
|
unsigned char buf[1];
|
420 |
|
|
struct timespec delay;
|
421 |
|
|
int loops = 0;
|
422 |
|
|
int result = 0;
|
423 |
|
|
|
424 |
|
|
VERBOSE(2, "Synchronizing with target\n");
|
425 |
|
|
|
426 |
|
|
while (1) {
|
427 |
|
|
buf[0] = 0;
|
428 |
|
|
usb_reliable_control_message(fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_SYNCH, 0, 0, 1, buf);
|
429 |
|
|
if (buf[0]) {
|
430 |
|
|
result = 1;
|
431 |
|
|
break;
|
432 |
|
|
} else {
|
433 |
|
|
if ((-1 != limit) && (++loops > limit)) {
|
434 |
|
|
break;
|
435 |
|
|
} else {
|
436 |
|
|
VERBOSE(3, "Not yet synchronized, sleeping\n");
|
437 |
|
|
delay.tv_sec = 0;
|
438 |
|
|
delay.tv_nsec = 100000000; // 100 ms
|
439 |
|
|
nanosleep(&delay, NULL);
|
440 |
|
|
}
|
441 |
|
|
}
|
442 |
|
|
}
|
443 |
|
|
VERBOSE(2, "%s\n", result ? "Synchronized" : "Not synchronized");
|
444 |
|
|
return result;
|
445 |
|
|
}
|
446 |
|
|
|
447 |
|
|
// Abort the target. Things seem to be completely messed up and there is no easy
|
448 |
|
|
// way to restore sanity to both target and host.
|
449 |
|
|
static void
|
450 |
|
|
usb_abort(int fd)
|
451 |
|
|
{
|
452 |
|
|
VERBOSE(2, "Target-side abort operation invoked\n");
|
453 |
|
|
usb_reliable_control_message(fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_ABORT, 0, 0, 0, (void*)0);
|
454 |
|
|
}
|
455 |
|
|
|
456 |
|
|
/*}}}*/
|
457 |
|
|
/*{{{ Initialise endpoints */
|
458 |
|
|
|
459 |
|
|
// ----------------------------------------------------------------------------
|
460 |
|
|
// On power-up some endpoints may not be in a sensible state. For example,
|
461 |
|
|
// with the SA11x0 the hardware may start accepting bulk OUT transfers
|
462 |
|
|
// before the target-side software has started a receive operation,
|
463 |
|
|
// so if the host sends a bulk packet before the target is ready then
|
464 |
|
|
// things get messy. This is especially troublesome if the target-side
|
465 |
|
|
// attempts any diagnostic output because of verbosity.
|
466 |
|
|
//
|
467 |
|
|
// This code loops through the various endpoints and makes sure that
|
468 |
|
|
// they are all in a reasonable state, before any real tests get run
|
469 |
|
|
// That means known hardware flaws do not show up as test failures,
|
470 |
|
|
// but of course they are still documented and application software
|
471 |
|
|
// will have to do the right thing.
|
472 |
|
|
|
473 |
|
|
static void
|
474 |
|
|
usb_initialise_control_endpoint(int min_size, int max_size)
|
475 |
|
|
{
|
476 |
|
|
// At this time there are no known problems on any hardware
|
477 |
|
|
// that would need to be addressed
|
478 |
|
|
}
|
479 |
|
|
|
480 |
|
|
static void
|
481 |
|
|
usb_initialise_isochronous_in_endpoint(int number, int min_size, int max_size)
|
482 |
|
|
{
|
483 |
|
|
// At this time there are no known problems on any hardware
|
484 |
|
|
// that would need to be addressed
|
485 |
|
|
}
|
486 |
|
|
|
487 |
|
|
static void
|
488 |
|
|
usb_initialise_isochronous_out_endpoint(int number, int min_size, int max_size)
|
489 |
|
|
{
|
490 |
|
|
// At this time there are no known problems on any hardware
|
491 |
|
|
// that would need to be addressed
|
492 |
|
|
}
|
493 |
|
|
|
494 |
|
|
static void
|
495 |
|
|
usb_initialise_bulk_in_endpoint(int number, int min_size, int max_size, int padding)
|
496 |
|
|
{
|
497 |
|
|
// At this time there are no known problems on any hardware
|
498 |
|
|
// that would need to be addressed
|
499 |
|
|
}
|
500 |
|
|
|
501 |
|
|
static void
|
502 |
|
|
usb_initialise_bulk_out_endpoint(int number, int min_size, int max_size)
|
503 |
|
|
{
|
504 |
|
|
unsigned char buf[1];
|
505 |
|
|
|
506 |
|
|
// On the SA1110 the hardware comes up with a bogus default value,
|
507 |
|
|
// causing the hardware to accept packets before the software has
|
508 |
|
|
// set up DMA or in any way prepared for incoming data. This is
|
509 |
|
|
// a problem. It is worked around by making the target receive
|
510 |
|
|
// a single packet, sending that packet, and then performing a
|
511 |
|
|
// sync.
|
512 |
|
|
VERBOSE(2, "Performing bulk OUT initialization on endpoint %d\n", number);
|
513 |
|
|
|
514 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN,
|
515 |
|
|
USBTEST_INIT_BULK_OUT, number, 0, 0, (void*) 0);
|
516 |
|
|
usb_bulk_message(usb_master_fd, number, buf, 1);
|
517 |
|
|
usb_sync(usb_master_fd, 10);
|
518 |
|
|
}
|
519 |
|
|
|
520 |
|
|
static void
|
521 |
|
|
usb_initialise_interrupt_in_endpoint(int number, int min_size, int max_size)
|
522 |
|
|
{
|
523 |
|
|
// At this time there are no known problems on any hardware
|
524 |
|
|
// that would need to be addressed
|
525 |
|
|
}
|
526 |
|
|
|
527 |
|
|
static void
|
528 |
|
|
usb_initialise_interrupt_out_endpoint(int number, int min_size, int max_size)
|
529 |
|
|
{
|
530 |
|
|
// At this time there are no known problems on any hardware
|
531 |
|
|
// that would need to be addressed
|
532 |
|
|
}
|
533 |
|
|
|
534 |
|
|
/*}}}*/
|
535 |
|
|
/*{{{ Host/target common code */
|
536 |
|
|
|
537 |
|
|
#define HOST
|
538 |
|
|
#include "../tests/common.c"
|
539 |
|
|
|
540 |
|
|
/*}}}*/
|
541 |
|
|
/*{{{ The test cases themselves */
|
542 |
|
|
|
543 |
|
|
/*{{{ UsbTest definition */
|
544 |
|
|
|
545 |
|
|
// ----------------------------------------------------------------------------
|
546 |
|
|
// All the data associated with a single test.
|
547 |
|
|
|
548 |
|
|
typedef struct UsbTest {
|
549 |
|
|
|
550 |
|
|
// A "unique" identifier to make verbose output easier to understand.
|
551 |
|
|
int id;
|
552 |
|
|
// Which file descriptor should be used to access USB.
|
553 |
|
|
int fd;
|
554 |
|
|
|
555 |
|
|
// Which test should be run.
|
556 |
|
|
usbtest which_test;
|
557 |
|
|
|
558 |
|
|
// Test-specific details.
|
559 |
|
|
union {
|
560 |
|
|
UsbTest_Bulk bulk;
|
561 |
|
|
UsbTest_ControlIn control_in;
|
562 |
|
|
} test_params;
|
563 |
|
|
|
564 |
|
|
// How to recover from any problems. Specifically, what kind of message
|
565 |
|
|
// could the target send or receive that would unlock the thread on this
|
566 |
|
|
// side.
|
567 |
|
|
UsbTest_Recovery recovery;
|
568 |
|
|
|
569 |
|
|
int result_pass;
|
570 |
|
|
char result_message[USBTEST_MAX_MESSAGE];
|
571 |
|
|
unsigned char buffer[USBTEST_MAX_BULK_DATA + USBTEST_MAX_BULK_DATA_EXTRA];
|
572 |
|
|
} UsbTest;
|
573 |
|
|
|
574 |
|
|
// Reset the information in a given test. This is used by the pool allocation
|
575 |
|
|
// code. The data union is left alone, filling in the appropriate union
|
576 |
|
|
// member is left to other code.
|
577 |
|
|
static void
|
578 |
|
|
reset_usbtest(UsbTest* test)
|
579 |
|
|
{
|
580 |
|
|
static int next_id = 1;
|
581 |
|
|
test->id = next_id++;
|
582 |
|
|
test->which_test = usbtest_invalid;
|
583 |
|
|
usbtest_recovery_reset(&(test->recovery));
|
584 |
|
|
test->result_pass = 0;
|
585 |
|
|
test->result_message[0] = '\0';
|
586 |
|
|
}
|
587 |
|
|
|
588 |
|
|
/*}}}*/
|
589 |
|
|
/*{{{ bulk OUT */
|
590 |
|
|
|
591 |
|
|
static void
|
592 |
|
|
run_test_bulk_out(UsbTest* test)
|
593 |
|
|
{
|
594 |
|
|
unsigned char* buf = test->buffer;
|
595 |
|
|
int i;
|
596 |
|
|
|
597 |
|
|
VERBOSE(1, "Starting test %d, bulk OUT on endpoint %d\n", test->id, test->test_params.bulk.endpoint);
|
598 |
|
|
|
599 |
|
|
for (i = 0; i < test->test_params.bulk.number_packets; i++) {
|
600 |
|
|
int transferred;
|
601 |
|
|
int packet_size = test->test_params.bulk.tx_size;
|
602 |
|
|
|
603 |
|
|
test->recovery.endpoint = test->test_params.bulk.endpoint;
|
604 |
|
|
test->recovery.protocol = USB_ENDPOINT_XFER_BULK;
|
605 |
|
|
test->recovery.size = packet_size;
|
606 |
|
|
|
607 |
|
|
usbtest_fill_buffer(&(test->test_params.bulk.data), buf, packet_size);
|
608 |
|
|
if (verbose < 3) {
|
609 |
|
|
VERBOSE(2, "Bulk OUT test %d: iteration %d, packet size %d\n", test->id, i, packet_size);
|
610 |
|
|
} else {
|
611 |
|
|
// Output the first 32 bytes of data as well.
|
612 |
|
|
char msg[256];
|
613 |
|
|
int index;
|
614 |
|
|
int j;
|
615 |
|
|
index = snprintf(msg, 255, "Bulk OUT test %d: iteration %d, packet size %d\n Data %s:",
|
616 |
|
|
test->id, i, packet_size,
|
617 |
|
|
(usbtestdata_none == test->test_params.bulk.data.format) ? "(uninitialized)" : "");
|
618 |
|
|
|
619 |
|
|
for (j = 0; ((j + 3) < packet_size) && (j < 32); j+= 4) {
|
620 |
|
|
index += snprintf(msg+index, 255-index, " %02x%02x%02x%02x",
|
621 |
|
|
buf[j], buf[j+1], buf[j+2], buf[j+3]);
|
622 |
|
|
}
|
623 |
|
|
if (j < 32) {
|
624 |
|
|
index += snprintf(msg+index, 255-index, " ");
|
625 |
|
|
for ( ; j < packet_size; j++) {
|
626 |
|
|
index += snprintf(msg+index, 255-index, "%02x", buf[j]);
|
627 |
|
|
}
|
628 |
|
|
|
629 |
|
|
}
|
630 |
|
|
VERBOSE(3, "%s\n", msg);
|
631 |
|
|
}
|
632 |
|
|
|
633 |
|
|
transferred = usb_bulk_message(test->fd, test->test_params.bulk.endpoint, buf, packet_size);
|
634 |
|
|
|
635 |
|
|
// Has this test run been aborted for some reason?
|
636 |
|
|
if (current_tests_terminated) {
|
637 |
|
|
VERBOSE(2, "Bulk OUT test %d: iteration %d, termination detected\n", test->id, i);
|
638 |
|
|
test->result_pass = 0;
|
639 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
640 |
|
|
"Host, bulk OUT transfer on endpoint %d: aborted after %d iterations\n",
|
641 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, i);
|
642 |
|
|
return;
|
643 |
|
|
}
|
644 |
|
|
|
645 |
|
|
// If an error occurred, abort this run.
|
646 |
|
|
if (-1 == transferred) {
|
647 |
|
|
char errno_buf[USBTEST_MAX_MESSAGE];
|
648 |
|
|
test->result_pass = 0;
|
649 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
650 |
|
|
"Host, bulk OUT transfer on endpoint %d : host ioctl() system call failed\n errno %d (%s)",
|
651 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, errno,
|
652 |
|
|
strerror_r(errno, errno_buf, USBTEST_MAX_MESSAGE));
|
653 |
|
|
VERBOSE(2, "Bulk OUT test %d: iteration %d, error:\n %s\n", test->id, i, test->result_message);
|
654 |
|
|
break;
|
655 |
|
|
}
|
656 |
|
|
|
657 |
|
|
if (0 != test->test_params.bulk.tx_delay) {
|
658 |
|
|
struct timespec delay;
|
659 |
|
|
|
660 |
|
|
VERBOSE(2, "Bulk OUT test %d: iteration %d, sleeping for %d nanoseconds\n", test->id, \
|
661 |
|
|
i, test->test_params.bulk.tx_delay);
|
662 |
|
|
// Note that nanosleep() can return early due to incoming signals,
|
663 |
|
|
// with the unelapsed time returned in a second argument. This
|
664 |
|
|
// allows for a retry loop. In practice this does not seem
|
665 |
|
|
// worthwhile, the delays are approximate anyway.
|
666 |
|
|
delay.tv_sec = test->test_params.bulk.tx_delay / 1000000000;
|
667 |
|
|
delay.tv_nsec = test->test_params.bulk.tx_delay % 1000000000;
|
668 |
|
|
nanosleep(&delay, NULL);
|
669 |
|
|
}
|
670 |
|
|
|
671 |
|
|
// Now move on to the next transfer
|
672 |
|
|
USBTEST_BULK_NEXT(test->test_params.bulk);
|
673 |
|
|
}
|
674 |
|
|
|
675 |
|
|
// If all the packets have been transferred this test has passed.
|
676 |
|
|
if (i >= test->test_params.bulk.number_packets) {
|
677 |
|
|
test->result_pass = 1;
|
678 |
|
|
}
|
679 |
|
|
|
680 |
|
|
VERBOSE(1, "Test %d bulk OUT on endpoint %d, result %d\n", test->id, test->test_params.bulk.endpoint, test->result_pass);
|
681 |
|
|
}
|
682 |
|
|
|
683 |
|
|
/*}}}*/
|
684 |
|
|
/*{{{ bulk IN */
|
685 |
|
|
|
686 |
|
|
static void
|
687 |
|
|
run_test_bulk_in(UsbTest* test)
|
688 |
|
|
{
|
689 |
|
|
unsigned char* buf = test->buffer;
|
690 |
|
|
int i;
|
691 |
|
|
|
692 |
|
|
VERBOSE(1, "Starting test %d bulk IN on endpoint %d\n", test->id, test->test_params.bulk.endpoint);
|
693 |
|
|
|
694 |
|
|
for (i = 0; i < test->test_params.bulk.number_packets; i++) {
|
695 |
|
|
int transferred;
|
696 |
|
|
int tx_size = test->test_params.bulk.tx_size;
|
697 |
|
|
int rx_size = test->test_params.bulk.rx_size;
|
698 |
|
|
int size_plus_padding;
|
699 |
|
|
|
700 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, rx size %d, tx size %d\n", test->id, i, rx_size, tx_size);
|
701 |
|
|
|
702 |
|
|
if (rx_size < tx_size) {
|
703 |
|
|
rx_size = tx_size;
|
704 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, packet size reset to %d to match tx size\n",
|
705 |
|
|
test->id, i, rx_size);
|
706 |
|
|
}
|
707 |
|
|
test->recovery.endpoint = test->test_params.bulk.endpoint;
|
708 |
|
|
test->recovery.protocol = USB_ENDPOINT_XFER_BULK;
|
709 |
|
|
test->recovery.size = rx_size;
|
710 |
|
|
|
711 |
|
|
// Make sure there is no old data lying around
|
712 |
|
|
if (usbtestdata_none != test->test_params.bulk.data.format) {
|
713 |
|
|
memset(buf, 0, rx_size);
|
714 |
|
|
}
|
715 |
|
|
|
716 |
|
|
// And do the actual transfer.
|
717 |
|
|
size_plus_padding = rx_size;
|
718 |
|
|
if (size_plus_padding < (tx_size + test->test_params.bulk.rx_padding)) {
|
719 |
|
|
size_plus_padding += test->test_params.bulk.rx_padding;
|
720 |
|
|
}
|
721 |
|
|
do {
|
722 |
|
|
transferred = usb_bulk_message(test->fd, test->test_params.bulk.endpoint, buf, size_plus_padding);
|
723 |
|
|
} while (0 == transferred);
|
724 |
|
|
|
725 |
|
|
// Has this test run been aborted for some reason?
|
726 |
|
|
if (current_tests_terminated) {
|
727 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, termination detected\n", test->id, i);
|
728 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
729 |
|
|
"Host, bulk IN transfer on endpoint %d: aborted after %d iterations\n",
|
730 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, i);
|
731 |
|
|
return;
|
732 |
|
|
}
|
733 |
|
|
|
734 |
|
|
// If an error occurred, abort this run.
|
735 |
|
|
if (-1 == transferred) {
|
736 |
|
|
char errno_buf[USBTEST_MAX_MESSAGE];
|
737 |
|
|
test->result_pass = 0;
|
738 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
739 |
|
|
"Host, bulk IN transfer on endpoint %d : host ioctl() system call failed\n errno %d (%s)",
|
740 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, errno,
|
741 |
|
|
strerror_r(errno, errno_buf, USBTEST_MAX_MESSAGE));
|
742 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, error:\n %s\n", test->id, i, test->result_message);
|
743 |
|
|
break;
|
744 |
|
|
}
|
745 |
|
|
|
746 |
|
|
// Did the target send the expected amount of data?
|
747 |
|
|
if (transferred < tx_size) {
|
748 |
|
|
test->result_pass = 0;
|
749 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
750 |
|
|
"Host, bulk IN transfer on endpoint %d : the target only sent %d bytes when %d were expected",
|
751 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, transferred, tx_size);
|
752 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, error:\n %s\n", test->id, i, test->result_message);
|
753 |
|
|
break;
|
754 |
|
|
}
|
755 |
|
|
|
756 |
|
|
if (verbose >= 3) {
|
757 |
|
|
// Output the first 32 bytes of data
|
758 |
|
|
char msg[256];
|
759 |
|
|
int index;
|
760 |
|
|
int j;
|
761 |
|
|
index = snprintf(msg, 255, "Bulk IN test %d: iteration %d, transferred %d\n Data %s:",
|
762 |
|
|
test->id, i, transferred,
|
763 |
|
|
(usbtestdata_none == test->test_params.bulk.data.format) ? "(uninitialized)" : "");
|
764 |
|
|
|
765 |
|
|
for (j = 0; ((j + 3) < transferred) && (j < 32); j+= 4) {
|
766 |
|
|
index += snprintf(msg+index, 255-index, " %02x%02x%02x%02x",
|
767 |
|
|
buf[j], buf[j+1], buf[j+2], buf[j+3]);
|
768 |
|
|
}
|
769 |
|
|
if (j < 32) {
|
770 |
|
|
index += snprintf(msg+index, 255-index, " ");
|
771 |
|
|
for ( ; j < transferred; j++) {
|
772 |
|
|
index += snprintf(msg+index, 255-index, "%02x", buf[j]);
|
773 |
|
|
}
|
774 |
|
|
|
775 |
|
|
}
|
776 |
|
|
VERBOSE(3, "%s\n", msg);
|
777 |
|
|
}
|
778 |
|
|
|
779 |
|
|
// Is the data correct?
|
780 |
|
|
if (!usbtest_check_buffer(&(test->test_params.bulk.data), buf, tx_size)) {
|
781 |
|
|
test->result_pass = 0;
|
782 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
783 |
|
|
"Host, bulk IN transfer on endpoint %d : mismatch between received and expected data",
|
784 |
|
|
test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK);
|
785 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, error:\n %s\n", test->id, i, test->result_message);
|
786 |
|
|
break;
|
787 |
|
|
}
|
788 |
|
|
|
789 |
|
|
if (0 != test->test_params.bulk.rx_delay) {
|
790 |
|
|
struct timespec delay;
|
791 |
|
|
|
792 |
|
|
VERBOSE(2, "Bulk IN test %d: iteration %d, sleeping for %d nanoseconds\n", test->id, \
|
793 |
|
|
i, test->test_params.bulk.tx_delay);
|
794 |
|
|
// Note that nanosleep() can return early due to incoming signals,
|
795 |
|
|
// with the unelapsed time returned in a second argument. This
|
796 |
|
|
// allows for a retry loop. In practice this does not seem
|
797 |
|
|
// worthwhile, the delays are approximate anyway.
|
798 |
|
|
delay.tv_sec = test->test_params.bulk.rx_delay / 1000000000;
|
799 |
|
|
delay.tv_nsec = test->test_params.bulk.rx_delay % 1000000000;
|
800 |
|
|
nanosleep(&delay, NULL);
|
801 |
|
|
}
|
802 |
|
|
|
803 |
|
|
USBTEST_BULK_NEXT(test->test_params.bulk);
|
804 |
|
|
}
|
805 |
|
|
|
806 |
|
|
|
807 |
|
|
// If all the packets have been transferred this test has passed.
|
808 |
|
|
if (i >= test->test_params.bulk.number_packets) {
|
809 |
|
|
test->result_pass = 1;
|
810 |
|
|
}
|
811 |
|
|
|
812 |
|
|
VERBOSE(1, "Test %d bulk IN on endpoint %d, result %d\n", test->id, test->test_params.bulk.endpoint, test->result_pass);
|
813 |
|
|
}
|
814 |
|
|
|
815 |
|
|
/*}}}*/
|
816 |
|
|
/*{{{ control IN */
|
817 |
|
|
|
818 |
|
|
// Receive appropriate packets via the control endpoint. This is somewhat
|
819 |
|
|
// different from bulk transfers. It is implemented using reserved control
|
820 |
|
|
// messages.
|
821 |
|
|
//
|
822 |
|
|
// Note: it is not entirely clear that this test is safe. There will be
|
823 |
|
|
// concurrent control traffic to detect test termination and the like,
|
824 |
|
|
// and these control messages may interfere with each other. It is not
|
825 |
|
|
// entirely clear how the Linux kernel handles concurrent control
|
826 |
|
|
// operations.
|
827 |
|
|
|
828 |
|
|
static void
|
829 |
|
|
run_test_control_in(UsbTest* test)
|
830 |
|
|
{
|
831 |
|
|
unsigned char* buf = test->buffer;
|
832 |
|
|
int packet_size;
|
833 |
|
|
int i;
|
834 |
|
|
|
835 |
|
|
packet_size = test->test_params.control_in.packet_size_initial;
|
836 |
|
|
for (i = 0; i < test->test_params.control_in.number_packets; i++) {
|
837 |
|
|
int transferred;
|
838 |
|
|
|
839 |
|
|
test->recovery.endpoint = 0;
|
840 |
|
|
test->recovery.protocol = USB_ENDPOINT_XFER_CONTROL;
|
841 |
|
|
test->recovery.size = packet_size;
|
842 |
|
|
|
843 |
|
|
// Make sure there is no old data lying around
|
844 |
|
|
if (usbtestdata_none != test->test_params.control_in.data.format) {
|
845 |
|
|
memset(buf, 0, packet_size);
|
846 |
|
|
}
|
847 |
|
|
|
848 |
|
|
// And do the actual transfer.
|
849 |
|
|
transferred = usb_control_message(test->fd, USB_TYPE_RESERVED | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_RESERVED_CONTROL_IN,
|
850 |
|
|
0, 0, packet_size, buf);
|
851 |
|
|
|
852 |
|
|
// Has this test run been aborted for some reason?
|
853 |
|
|
if (current_tests_terminated) {
|
854 |
|
|
return;
|
855 |
|
|
}
|
856 |
|
|
|
857 |
|
|
// If an error occurred, abort this run.
|
858 |
|
|
if (-1 == transferred) {
|
859 |
|
|
char errno_buf[USBTEST_MAX_MESSAGE];
|
860 |
|
|
test->result_pass = 0;
|
861 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
862 |
|
|
"Host, control IN transfer: host ioctl() system call failed\n errno %d (%s)",
|
863 |
|
|
errno, strerror_r(errno, errno_buf, USBTEST_MAX_MESSAGE));
|
864 |
|
|
break;
|
865 |
|
|
}
|
866 |
|
|
|
867 |
|
|
// Did the target send the expected amount of data?
|
868 |
|
|
if (transferred < packet_size) {
|
869 |
|
|
test->result_pass = 0;
|
870 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
871 |
|
|
"Host, control IN transfer: the target only sent %d bytes when %d were expected",
|
872 |
|
|
transferred, packet_size);
|
873 |
|
|
break;
|
874 |
|
|
}
|
875 |
|
|
|
876 |
|
|
// Is the data correct?
|
877 |
|
|
if (!usbtest_check_buffer(&(test->test_params.control_in.data), buf, packet_size)) {
|
878 |
|
|
test->result_pass = 0;
|
879 |
|
|
snprintf(test->result_message, USBTEST_MAX_MESSAGE,
|
880 |
|
|
"Host, control IN transfer: mismatch between received and expected data");
|
881 |
|
|
break;
|
882 |
|
|
}
|
883 |
|
|
|
884 |
|
|
USBTEST_CONTROL_NEXT_PACKET_SIZE(packet_size, test->test_params.control_in);
|
885 |
|
|
}
|
886 |
|
|
|
887 |
|
|
// If all the packets have been transferred this test has passed.
|
888 |
|
|
if (i >= test->test_params.control_in.number_packets) {
|
889 |
|
|
test->result_pass = 1;
|
890 |
|
|
}
|
891 |
|
|
}
|
892 |
|
|
|
893 |
|
|
/*}}}*/
|
894 |
|
|
|
895 |
|
|
// FIXME: add more tests
|
896 |
|
|
|
897 |
|
|
/*{{{ run_test() */
|
898 |
|
|
|
899 |
|
|
// This utility is invoked from a thread in the thread pool whenever there is
|
900 |
|
|
// work to be done. It simply dispatches to the appropriate handler.
|
901 |
|
|
static void
|
902 |
|
|
run_test(UsbTest* test)
|
903 |
|
|
{
|
904 |
|
|
switch (test->which_test) {
|
905 |
|
|
case usbtest_bulk_out: run_test_bulk_out(test); break;
|
906 |
|
|
case usbtest_bulk_in: run_test_bulk_in(test); break;
|
907 |
|
|
case usbtest_control_in: run_test_control_in(test); break;
|
908 |
|
|
default:
|
909 |
|
|
fprintf(stderr, "usbhost: internal error, attempt to execute an unknown test.\n");
|
910 |
|
|
exit(EXIT_FAILURE);
|
911 |
|
|
}
|
912 |
|
|
}
|
913 |
|
|
|
914 |
|
|
/*}}}*/
|
915 |
|
|
|
916 |
|
|
/*}}}*/
|
917 |
|
|
/*{{{ The thread pool */
|
918 |
|
|
|
919 |
|
|
// ----------------------------------------------------------------------------
|
920 |
|
|
// A pool of threads and buffers which do the real work. The number of possible
|
921 |
|
|
// concurrent tests is defined in protocol.h. Each one requires a separate
|
922 |
|
|
// thread, transfer buffer, semaphore, and some state information.
|
923 |
|
|
//
|
924 |
|
|
// Although the application is multi-threaded, in practice there is little
|
925 |
|
|
// need for synchronization. Tests will only be started while the pool threads
|
926 |
|
|
// are idle. When the pool threads are running the main thread will be waiting
|
927 |
|
|
// for them all to finish, with a bit of polling to detect error conditions.
|
928 |
|
|
// The pool threads do not share any data, apart from the file descriptor for
|
929 |
|
|
// the USB device.
|
930 |
|
|
|
931 |
|
|
typedef struct PoolEntry {
|
932 |
|
|
pthread_t thread;
|
933 |
|
|
sem_t wakeup;
|
934 |
|
|
int running;
|
935 |
|
|
UsbTest test;
|
936 |
|
|
} PoolEntry;
|
937 |
|
|
|
938 |
|
|
static PoolEntry pool[USBTEST_MAX_CONCURRENT_TESTS];
|
939 |
|
|
|
940 |
|
|
// This is the entry point for every thread in the pool. It just loops forever,
|
941 |
|
|
// waiting until it is supposed to run a test. These threads never actually
|
942 |
|
|
// exit, instead there should be a call to exit() somewhere.
|
943 |
|
|
static void*
|
944 |
|
|
pool_function(void* arg)
|
945 |
|
|
{
|
946 |
|
|
PoolEntry* pool_entry = (PoolEntry*) arg;
|
947 |
|
|
int ret;
|
948 |
|
|
|
949 |
|
|
for ( ; ; ) {
|
950 |
|
|
do {
|
951 |
|
|
ret = sem_wait(&(pool_entry->wakeup));
|
952 |
|
|
if (ret != 0 && errno != EINTR) {
|
953 |
|
|
perror("sem_wait");
|
954 |
|
|
exit(1);
|
955 |
|
|
}
|
956 |
|
|
} while (ret != 0);
|
957 |
|
|
run_test(&(pool_entry->test));
|
958 |
|
|
pool_entry->running = 0;
|
959 |
|
|
}
|
960 |
|
|
|
961 |
|
|
return NULL;
|
962 |
|
|
}
|
963 |
|
|
|
964 |
|
|
// Initialize all threads in the pool.
|
965 |
|
|
static void
|
966 |
|
|
pool_initialize(void)
|
967 |
|
|
{
|
968 |
|
|
int i;
|
969 |
|
|
for (i = 0; i < USBTEST_MAX_CONCURRENT_TESTS; i++) {
|
970 |
|
|
pool[i].running = 0;
|
971 |
|
|
pool[i].test.fd = dup(usb_master_fd);
|
972 |
|
|
if (0 != sem_init(&(pool[i].wakeup), 0, 0)) {
|
973 |
|
|
fprintf(stderr, "usbhost: internal error, failed to initialize all semaphores.\n");
|
974 |
|
|
exit(EXIT_FAILURE);
|
975 |
|
|
}
|
976 |
|
|
if (0 != pthread_create(&(pool[i].thread), NULL, &pool_function, (void*) &(pool[i]))) {
|
977 |
|
|
fprintf(stderr, "usbhost: internal error, failed to start all threads.\n");
|
978 |
|
|
exit(EXIT_FAILURE);
|
979 |
|
|
}
|
980 |
|
|
}
|
981 |
|
|
}
|
982 |
|
|
|
983 |
|
|
// Allocate a single entry in the thread pool.
|
984 |
|
|
static UsbTest*
|
985 |
|
|
pool_allocate(void)
|
986 |
|
|
{
|
987 |
|
|
UsbTest* result = (UsbTest*) 0;
|
988 |
|
|
|
989 |
|
|
if (local_thread_count == USBTEST_MAX_CONCURRENT_TESTS) {
|
990 |
|
|
fprintf(stderr, "usbhost: internal error, thread resource exhausted.\n");
|
991 |
|
|
exit(EXIT_FAILURE);
|
992 |
|
|
}
|
993 |
|
|
|
994 |
|
|
result = &(pool[local_thread_count].test);
|
995 |
|
|
local_thread_count++;
|
996 |
|
|
reset_usbtest(result);
|
997 |
|
|
return result;
|
998 |
|
|
}
|
999 |
|
|
|
1000 |
|
|
// Start all the threads that are supposed to be running tests.
|
1001 |
|
|
static void
|
1002 |
|
|
pool_start(void)
|
1003 |
|
|
{
|
1004 |
|
|
int i;
|
1005 |
|
|
for (i = 0; i < local_thread_count; i++) {
|
1006 |
|
|
pool[i].running = 1;
|
1007 |
|
|
sem_post(&(pool[i].wakeup));
|
1008 |
|
|
}
|
1009 |
|
|
}
|
1010 |
|
|
|
1011 |
|
|
/*}}}*/
|
1012 |
|
|
/*{{{ Tcl routines */
|
1013 |
|
|
|
1014 |
|
|
// ----------------------------------------------------------------------------
|
1015 |
|
|
// Tcl routines to provide access to the USB device from inside Tcl
|
1016 |
|
|
// scripts, plus some general utilities. These routines deal mostly
|
1017 |
|
|
// with preparing a test run. The actual work is done in C: the
|
1018 |
|
|
// ioctl() operations are not readily accessible from Tcl, and
|
1019 |
|
|
// operations like filling in buffers and calculating checksums are
|
1020 |
|
|
// cpu-intensive.
|
1021 |
|
|
|
1022 |
|
|
/*{{{ pass/fail/abort */
|
1023 |
|
|
|
1024 |
|
|
// ----------------------------------------------------------------------------
|
1025 |
|
|
// Some simple routines accessible from Tcl to get the target to report pass/fail or
|
1026 |
|
|
// to make the target abort.
|
1027 |
|
|
|
1028 |
|
|
static int
|
1029 |
|
|
tcl_target_pass(ClientData clientData __attribute__ ((unused)),
|
1030 |
|
|
Tcl_Interp* interp,
|
1031 |
|
|
int argc,
|
1032 |
|
|
char** argv)
|
1033 |
|
|
{
|
1034 |
|
|
if (2 != argc) {
|
1035 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_pass <message>\"", TCL_STATIC);
|
1036 |
|
|
return TCL_ERROR;
|
1037 |
|
|
}
|
1038 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_PASS, 0, 0, strlen(argv[1]) + 1, argv[1]);
|
1039 |
|
|
usb_sync(usb_master_fd, -1);
|
1040 |
|
|
return TCL_OK;
|
1041 |
|
|
}
|
1042 |
|
|
|
1043 |
|
|
static int
|
1044 |
|
|
tcl_target_fail(ClientData clientData __attribute__ ((unused)),
|
1045 |
|
|
Tcl_Interp* interp,
|
1046 |
|
|
int argc,
|
1047 |
|
|
char** argv)
|
1048 |
|
|
{
|
1049 |
|
|
if (2 != argc) {
|
1050 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_fail <message>\"", TCL_STATIC);
|
1051 |
|
|
return TCL_ERROR;
|
1052 |
|
|
}
|
1053 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_FAIL, 0, 0, strlen(argv[1]) + 1, argv[1]);
|
1054 |
|
|
usb_sync(usb_master_fd, -1);
|
1055 |
|
|
return TCL_OK;
|
1056 |
|
|
}
|
1057 |
|
|
|
1058 |
|
|
// The next three routines cause the target to exit, so a usb_sync() is inappropriate.
|
1059 |
|
|
static int
|
1060 |
|
|
tcl_target_pass_exit(ClientData clientData __attribute__ ((unused)),
|
1061 |
|
|
Tcl_Interp* interp,
|
1062 |
|
|
int argc,
|
1063 |
|
|
char** argv)
|
1064 |
|
|
{
|
1065 |
|
|
if (2 != argc) {
|
1066 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_pass_exit <message>\"", TCL_STATIC);
|
1067 |
|
|
return TCL_ERROR;
|
1068 |
|
|
}
|
1069 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_PASS_EXIT, 0, 0,
|
1070 |
|
|
strlen(argv[1]) + 1, argv[1]);
|
1071 |
|
|
return TCL_OK;
|
1072 |
|
|
}
|
1073 |
|
|
|
1074 |
|
|
|
1075 |
|
|
static int
|
1076 |
|
|
tcl_target_fail_exit(ClientData clientData __attribute__ ((unused)),
|
1077 |
|
|
Tcl_Interp* interp,
|
1078 |
|
|
int argc,
|
1079 |
|
|
char** argv)
|
1080 |
|
|
{
|
1081 |
|
|
if (2 != argc) {
|
1082 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_fail_exit <message>\"", TCL_STATIC);
|
1083 |
|
|
return TCL_ERROR;
|
1084 |
|
|
}
|
1085 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_FAIL_EXIT, 0, 0,
|
1086 |
|
|
strlen(argv[1]) + 1, argv[1]);
|
1087 |
|
|
return TCL_OK;
|
1088 |
|
|
}
|
1089 |
|
|
|
1090 |
|
|
static int
|
1091 |
|
|
tcl_target_abort(ClientData clientData __attribute__ ((unused)),
|
1092 |
|
|
Tcl_Interp* interp,
|
1093 |
|
|
int argc,
|
1094 |
|
|
char** argv __attribute__ ((unused)) )
|
1095 |
|
|
{
|
1096 |
|
|
if (1 != argc) {
|
1097 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_abort\"", TCL_STATIC);
|
1098 |
|
|
return TCL_ERROR;
|
1099 |
|
|
}
|
1100 |
|
|
usb_abort(usb_master_fd);
|
1101 |
|
|
return TCL_OK;
|
1102 |
|
|
}
|
1103 |
|
|
|
1104 |
|
|
/*}}}*/
|
1105 |
|
|
/*{{{ start bulk test */
|
1106 |
|
|
|
1107 |
|
|
// ----------------------------------------------------------------------------
|
1108 |
|
|
// Start a bulk test. The real Tcl interface to this functionality is
|
1109 |
|
|
// implemented in Tcl: it takes care of figuring out sensible default
|
1110 |
|
|
// arguments, validating the data, etc. All that this code does is
|
1111 |
|
|
// allocate a thread and fill in the appropriate data, plus request
|
1112 |
|
|
// the target-side to do the same thing.
|
1113 |
|
|
|
1114 |
|
|
static int
|
1115 |
|
|
tcl_test_bulk(ClientData clientData __attribute__ ((unused)),
|
1116 |
|
|
Tcl_Interp* interp,
|
1117 |
|
|
int argc,
|
1118 |
|
|
char** argv)
|
1119 |
|
|
{
|
1120 |
|
|
int i;
|
1121 |
|
|
int tmp;
|
1122 |
|
|
UsbTest* test;
|
1123 |
|
|
unsigned char request[USBTEST_MAX_CONTROL_DATA];
|
1124 |
|
|
int request_index;
|
1125 |
|
|
|
1126 |
|
|
// The data consists of 28 numbers for UsbTest_Bulk itself, and
|
1127 |
|
|
// another 10 numbers for the test data definition.
|
1128 |
|
|
if (39 != argc) {
|
1129 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::_test_bulk <message>\"", TCL_STATIC);
|
1130 |
|
|
return TCL_ERROR;
|
1131 |
|
|
}
|
1132 |
|
|
for (i = 1; i < 39; i++) {
|
1133 |
|
|
int discard;
|
1134 |
|
|
if (TCL_OK != Tcl_GetInt(interp, argv[i], &discard)) {
|
1135 |
|
|
Tcl_SetResult(interp, "invalid argument: all arguments should be numbers", TCL_STATIC);
|
1136 |
|
|
return TCL_ERROR;
|
1137 |
|
|
}
|
1138 |
|
|
}
|
1139 |
|
|
|
1140 |
|
|
test = pool_allocate();
|
1141 |
|
|
Tcl_GetInt(interp, argv[1], &(test->test_params.bulk.number_packets));
|
1142 |
|
|
Tcl_GetInt(interp, argv[2], &(test->test_params.bulk.endpoint));
|
1143 |
|
|
test->which_test = (USB_DIR_IN == (test->test_params.bulk.endpoint & USB_ENDPOINT_DIR_MASK))
|
1144 |
|
|
? usbtest_bulk_in : usbtest_bulk_out;
|
1145 |
|
|
Tcl_GetInt(interp, argv[ 3], &(test->test_params.bulk.tx_size));
|
1146 |
|
|
Tcl_GetInt(interp, argv[ 4], &(test->test_params.bulk.tx_size_min));
|
1147 |
|
|
Tcl_GetInt(interp, argv[ 5], &(test->test_params.bulk.tx_size_max));
|
1148 |
|
|
Tcl_GetInt(interp, argv[ 6], &(test->test_params.bulk.tx_size_multiplier));
|
1149 |
|
|
Tcl_GetInt(interp, argv[ 7], &(test->test_params.bulk.tx_size_divisor));
|
1150 |
|
|
Tcl_GetInt(interp, argv[ 8], &(test->test_params.bulk.tx_size_increment));
|
1151 |
|
|
Tcl_GetInt(interp, argv[ 9], &(test->test_params.bulk.rx_size));
|
1152 |
|
|
Tcl_GetInt(interp, argv[10], &(test->test_params.bulk.rx_size_min));
|
1153 |
|
|
Tcl_GetInt(interp, argv[11], &(test->test_params.bulk.rx_size_max));
|
1154 |
|
|
Tcl_GetInt(interp, argv[12], &(test->test_params.bulk.rx_size_multiplier));
|
1155 |
|
|
Tcl_GetInt(interp, argv[13], &(test->test_params.bulk.rx_size_divisor));
|
1156 |
|
|
Tcl_GetInt(interp, argv[14], &(test->test_params.bulk.rx_size_increment));
|
1157 |
|
|
Tcl_GetInt(interp, argv[15], &(test->test_params.bulk.rx_padding));
|
1158 |
|
|
Tcl_GetInt(interp, argv[16], &(test->test_params.bulk.tx_delay));
|
1159 |
|
|
Tcl_GetInt(interp, argv[17], &(test->test_params.bulk.tx_delay_min));
|
1160 |
|
|
Tcl_GetInt(interp, argv[18], &(test->test_params.bulk.tx_delay_max));
|
1161 |
|
|
Tcl_GetInt(interp, argv[19], &(test->test_params.bulk.tx_delay_multiplier));
|
1162 |
|
|
Tcl_GetInt(interp, argv[20], &(test->test_params.bulk.tx_delay_divisor));
|
1163 |
|
|
Tcl_GetInt(interp, argv[21], &(test->test_params.bulk.tx_delay_increment));
|
1164 |
|
|
Tcl_GetInt(interp, argv[22], &(test->test_params.bulk.rx_delay));
|
1165 |
|
|
Tcl_GetInt(interp, argv[23], &(test->test_params.bulk.rx_delay_min));
|
1166 |
|
|
Tcl_GetInt(interp, argv[24], &(test->test_params.bulk.rx_delay_max));
|
1167 |
|
|
Tcl_GetInt(interp, argv[25], &(test->test_params.bulk.rx_delay_multiplier));
|
1168 |
|
|
Tcl_GetInt(interp, argv[26], &(test->test_params.bulk.rx_delay_divisor));
|
1169 |
|
|
Tcl_GetInt(interp, argv[27], &(test->test_params.bulk.rx_delay_increment));
|
1170 |
|
|
Tcl_GetInt(interp, argv[28], &tmp);
|
1171 |
|
|
test->test_params.bulk.io_mechanism = (usb_io_mechanism) tmp;
|
1172 |
|
|
Tcl_GetInt(interp, argv[29], &tmp);
|
1173 |
|
|
test->test_params.bulk.data.format = (usbtestdata) tmp;
|
1174 |
|
|
Tcl_GetInt(interp, argv[30], &(test->test_params.bulk.data.seed));
|
1175 |
|
|
Tcl_GetInt(interp, argv[31], &(test->test_params.bulk.data.multiplier));
|
1176 |
|
|
Tcl_GetInt(interp, argv[32], &(test->test_params.bulk.data.increment));
|
1177 |
|
|
Tcl_GetInt(interp, argv[33], &(test->test_params.bulk.data.transfer_seed_multiplier));
|
1178 |
|
|
Tcl_GetInt(interp, argv[34], &(test->test_params.bulk.data.transfer_seed_increment));
|
1179 |
|
|
Tcl_GetInt(interp, argv[35], &(test->test_params.bulk.data.transfer_multiplier_multiplier));
|
1180 |
|
|
Tcl_GetInt(interp, argv[36], &(test->test_params.bulk.data.transfer_multiplier_increment));
|
1181 |
|
|
Tcl_GetInt(interp, argv[37], &(test->test_params.bulk.data.transfer_increment_multiplier));
|
1182 |
|
|
Tcl_GetInt(interp, argv[38], &(test->test_params.bulk.data.transfer_increment_increment));
|
1183 |
|
|
|
1184 |
|
|
VERBOSE(3, "Preparing USB bulk test on endpoint %d, direction %s, for %d packets\n", \
|
1185 |
|
|
test->test_params.bulk.endpoint, \
|
1186 |
|
|
(usbtest_bulk_in == test->which_test) ? "IN" : "OUT", \
|
1187 |
|
|
test->test_params.bulk.number_packets);
|
1188 |
|
|
VERBOSE(3, " I/O mechanism is %s\n", \
|
1189 |
|
|
(usb_io_mechanism_usb == test->test_params.bulk.io_mechanism) ? "low-level USB" : \
|
1190 |
|
|
(usb_io_mechanism_dev == test->test_params.bulk.io_mechanism) ? "devtab" : "<invalid>");
|
1191 |
|
|
VERBOSE(3, " Data format %s, data1 %d, data* %d, data+ %d, data1* %d, data1+ %d, data** %d, data*+ %d, data+* %d, data++ %d\n",\
|
1192 |
|
|
(usbtestdata_none == test->test_params.bulk.data.format) ? "none" : \
|
1193 |
|
|
(usbtestdata_bytefill == test->test_params.bulk.data.format) ? "bytefill" : \
|
1194 |
|
|
(usbtestdata_wordfill == test->test_params.bulk.data.format) ? "wordfill" : \
|
1195 |
|
|
(usbtestdata_byteseq == test->test_params.bulk.data.format) ? "byteseq" : \
|
1196 |
|
|
(usbtestdata_wordseq == test->test_params.bulk.data.format) ? "wordseq" : "<invalid>", \
|
1197 |
|
|
test->test_params.bulk.data.seed, \
|
1198 |
|
|
test->test_params.bulk.data.multiplier, \
|
1199 |
|
|
test->test_params.bulk.data.increment, \
|
1200 |
|
|
test->test_params.bulk.data.transfer_seed_multiplier, \
|
1201 |
|
|
test->test_params.bulk.data.transfer_seed_increment, \
|
1202 |
|
|
test->test_params.bulk.data.transfer_multiplier_multiplier, \
|
1203 |
|
|
test->test_params.bulk.data.transfer_multiplier_increment, \
|
1204 |
|
|
test->test_params.bulk.data.transfer_increment_multiplier, \
|
1205 |
|
|
test->test_params.bulk.data.transfer_increment_increment);
|
1206 |
|
|
VERBOSE(3, " txsize1 %d, txsize>= %d, txsize<= %d, txsize* %d, txsize/ %d, txsize+ %d\n", \
|
1207 |
|
|
test->test_params.bulk.tx_size, test->test_params.bulk.tx_size_min, \
|
1208 |
|
|
test->test_params.bulk.tx_size_max, test->test_params.bulk.tx_size_multiplier, \
|
1209 |
|
|
test->test_params.bulk.tx_size_divisor, test->test_params.bulk.tx_size_increment);
|
1210 |
|
|
VERBOSE(3, " rxsize1 %d, rxsize>= %d, rxsize<= %d, rxsize* %d, rxsize/ %d, rxsize+ %d\n", \
|
1211 |
|
|
test->test_params.bulk.rx_size, test->test_params.bulk.rx_size_min, \
|
1212 |
|
|
test->test_params.bulk.rx_size_max, test->test_params.bulk.rx_size_multiplier, \
|
1213 |
|
|
test->test_params.bulk.rx_size_divisor, test->test_params.bulk.rx_size_increment);
|
1214 |
|
|
VERBOSE(3, " txdelay1 %d, txdelay>= %d, txdelay<= %d, txdelay* %d, txdelay/ %d, txdelay+ %d\n", \
|
1215 |
|
|
test->test_params.bulk.tx_delay, test->test_params.bulk.tx_delay_min, \
|
1216 |
|
|
test->test_params.bulk.tx_delay_max, test->test_params.bulk.tx_delay_multiplier, \
|
1217 |
|
|
test->test_params.bulk.tx_delay_divisor, test->test_params.bulk.tx_delay_increment);
|
1218 |
|
|
VERBOSE(3, " rxdelay1 %d, rxdelay>= %d, rxdelay<= %d, rxdelay* %d, rxdelay/ %d, rxdelay+ %d\n", \
|
1219 |
|
|
test->test_params.bulk.rx_delay, test->test_params.bulk.rx_delay_min, \
|
1220 |
|
|
test->test_params.bulk.rx_delay_max, test->test_params.bulk.rx_delay_multiplier, \
|
1221 |
|
|
test->test_params.bulk.rx_delay_divisor, test->test_params.bulk.rx_delay_increment);
|
1222 |
|
|
|
1223 |
|
|
|
1224 |
|
|
// That is all the data converted from Tcl to C, and a local thread is set up to handle this
|
1225 |
|
|
// request. Also set up a thread on the target.
|
1226 |
|
|
request_index = 0;
|
1227 |
|
|
pack_usbtest_bulk(&(test->test_params.bulk), request, &request_index);
|
1228 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_TEST_BULK, 0, 0, request_index, request);
|
1229 |
|
|
remote_thread_count++;
|
1230 |
|
|
|
1231 |
|
|
return TCL_OK;
|
1232 |
|
|
}
|
1233 |
|
|
|
1234 |
|
|
/*}}}*/
|
1235 |
|
|
/*{{{ start control-in test */
|
1236 |
|
|
|
1237 |
|
|
// ----------------------------------------------------------------------------
|
1238 |
|
|
// Start a control-in test. The real Tcl interface to this
|
1239 |
|
|
// functionality is implemented in Tcl: it takes care of figuring out
|
1240 |
|
|
// sensible default arguments, validating the data, etc. All that this
|
1241 |
|
|
// code does is allocate a thread and fill in the appropriate data,
|
1242 |
|
|
// plus request the target-side to do the same thing.
|
1243 |
|
|
|
1244 |
|
|
static int
|
1245 |
|
|
tcl_test_control_in(ClientData clientData __attribute__ ((unused)),
|
1246 |
|
|
Tcl_Interp* interp,
|
1247 |
|
|
int argc,
|
1248 |
|
|
char** argv)
|
1249 |
|
|
{
|
1250 |
|
|
int i;
|
1251 |
|
|
int tmp;
|
1252 |
|
|
UsbTest* test;
|
1253 |
|
|
unsigned char request[USBTEST_MAX_CONTROL_DATA];
|
1254 |
|
|
int request_index;
|
1255 |
|
|
|
1256 |
|
|
// The data consists of 6 numbers for UsbTest_ControlIn itself, and
|
1257 |
|
|
// another 10 numbers for the test data definition.
|
1258 |
|
|
if (17 != argc) {
|
1259 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::_test_control_in <message>\"", TCL_STATIC);
|
1260 |
|
|
return TCL_ERROR;
|
1261 |
|
|
}
|
1262 |
|
|
for (i = 1; i < 17; i++) {
|
1263 |
|
|
int discard;
|
1264 |
|
|
if (TCL_OK != Tcl_GetInt(interp, argv[i], &discard)) {
|
1265 |
|
|
Tcl_SetResult(interp, "invalid argument: all arguments should be numbers", TCL_STATIC);
|
1266 |
|
|
return TCL_ERROR;
|
1267 |
|
|
}
|
1268 |
|
|
}
|
1269 |
|
|
|
1270 |
|
|
test = pool_allocate();
|
1271 |
|
|
test->which_test = usbtest_control_in;
|
1272 |
|
|
Tcl_GetInt(interp, argv[1], &(test->test_params.control_in.number_packets));
|
1273 |
|
|
Tcl_GetInt(interp, argv[2], &(test->test_params.control_in.packet_size_initial));
|
1274 |
|
|
Tcl_GetInt(interp, argv[3], &(test->test_params.control_in.packet_size_min));
|
1275 |
|
|
Tcl_GetInt(interp, argv[4], &(test->test_params.control_in.packet_size_max));
|
1276 |
|
|
Tcl_GetInt(interp, argv[5], &(test->test_params.control_in.packet_size_multiplier));
|
1277 |
|
|
Tcl_GetInt(interp, argv[6], &(test->test_params.control_in.packet_size_increment));
|
1278 |
|
|
Tcl_GetInt(interp, argv[7], &tmp);
|
1279 |
|
|
test->test_params.bulk.data.format = (usbtestdata) tmp;
|
1280 |
|
|
Tcl_GetInt(interp, argv[ 8], &(test->test_params.control_in.data.seed));
|
1281 |
|
|
Tcl_GetInt(interp, argv[ 9], &(test->test_params.control_in.data.multiplier));
|
1282 |
|
|
Tcl_GetInt(interp, argv[10], &(test->test_params.control_in.data.increment));
|
1283 |
|
|
Tcl_GetInt(interp, argv[11], &(test->test_params.control_in.data.transfer_seed_multiplier));
|
1284 |
|
|
Tcl_GetInt(interp, argv[12], &(test->test_params.control_in.data.transfer_seed_increment));
|
1285 |
|
|
Tcl_GetInt(interp, argv[13], &(test->test_params.control_in.data.transfer_multiplier_multiplier));
|
1286 |
|
|
Tcl_GetInt(interp, argv[14], &(test->test_params.control_in.data.transfer_multiplier_increment));
|
1287 |
|
|
Tcl_GetInt(interp, argv[15], &(test->test_params.control_in.data.transfer_increment_multiplier));
|
1288 |
|
|
Tcl_GetInt(interp, argv[16], &(test->test_params.control_in.data.transfer_increment_increment));
|
1289 |
|
|
|
1290 |
|
|
// That is all the data converted from Tcl to C, and a local thread is set up to handle this
|
1291 |
|
|
// request. Also set up a thread on the target.
|
1292 |
|
|
request_index = 0;
|
1293 |
|
|
pack_usbtest_control_in(&(test->test_params.control_in), request, &request_index);
|
1294 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_TEST_CONTROL_IN, 0, 0,
|
1295 |
|
|
request_index, request);
|
1296 |
|
|
remote_thread_count++;
|
1297 |
|
|
|
1298 |
|
|
return TCL_OK;
|
1299 |
|
|
}
|
1300 |
|
|
|
1301 |
|
|
/*}}}*/
|
1302 |
|
|
/*{{{ Cancel the current batch of tests */
|
1303 |
|
|
|
1304 |
|
|
static int
|
1305 |
|
|
tcl_cancel(ClientData clientData __attribute__ ((unused)),
|
1306 |
|
|
Tcl_Interp* interp,
|
1307 |
|
|
int argc,
|
1308 |
|
|
char** argv __attribute__ ((unused)) )
|
1309 |
|
|
{
|
1310 |
|
|
if (1 != argc) {
|
1311 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::cancel\"", TCL_STATIC);
|
1312 |
|
|
return TCL_ERROR;
|
1313 |
|
|
}
|
1314 |
|
|
|
1315 |
|
|
// Send the request on to the target.
|
1316 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_CANCEL, 0, 0, 0, (void*)0);
|
1317 |
|
|
|
1318 |
|
|
// Now cancel all the local tests. This can be done by resetting the counter
|
1319 |
|
|
// of allocated threads: no actual work will have been started yet.
|
1320 |
|
|
local_thread_count = 0;
|
1321 |
|
|
|
1322 |
|
|
// And synchronise with the target
|
1323 |
|
|
if (!usb_sync(usb_master_fd, 30)) {
|
1324 |
|
|
fprintf(stderr, "usbhost: error, target has failed to process test cancel request.\n");
|
1325 |
|
|
exit(EXIT_FAILURE);
|
1326 |
|
|
|
1327 |
|
|
}
|
1328 |
|
|
remote_thread_count = 0;
|
1329 |
|
|
|
1330 |
|
|
return TCL_OK;
|
1331 |
|
|
}
|
1332 |
|
|
|
1333 |
|
|
/*}}}*/
|
1334 |
|
|
/*{{{ Run a batch of tests */
|
1335 |
|
|
|
1336 |
|
|
// ----------------------------------------------------------------------------
|
1337 |
|
|
// This code does an awful lot of the hard work. Start with various utilities.
|
1338 |
|
|
|
1339 |
|
|
// Has the current batch finished as far as the local threads are concerned?
|
1340 |
|
|
static int
|
1341 |
|
|
local_batch_finished(void)
|
1342 |
|
|
{
|
1343 |
|
|
int result = 1;
|
1344 |
|
|
int i;
|
1345 |
|
|
|
1346 |
|
|
for (i = 0; i < local_thread_count; i++) {
|
1347 |
|
|
if (pool[i].running) {
|
1348 |
|
|
result = 0;
|
1349 |
|
|
break;
|
1350 |
|
|
}
|
1351 |
|
|
}
|
1352 |
|
|
return result;
|
1353 |
|
|
}
|
1354 |
|
|
|
1355 |
|
|
// Has the current batch finished as far as remote threads are concerned?
|
1356 |
|
|
static int
|
1357 |
|
|
remote_batch_finished(void)
|
1358 |
|
|
{
|
1359 |
|
|
char buf[1];
|
1360 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_FINISHED,
|
1361 |
|
|
0, 0, 1, (void*) buf);
|
1362 |
|
|
return buf[0];
|
1363 |
|
|
}
|
1364 |
|
|
|
1365 |
|
|
// Perform recovery for a thread on the target. This involves asking the
|
1366 |
|
|
// target for recovery information, then performing an appropriate
|
1367 |
|
|
// action. If no data is returned then no recovery is needed for this thread.
|
1368 |
|
|
static void
|
1369 |
|
|
recover_remote(int index)
|
1370 |
|
|
{
|
1371 |
|
|
unsigned char buffer[USBTEST_MAX_CONTROL_DATA];
|
1372 |
|
|
int buffer_index;
|
1373 |
|
|
UsbTest_Recovery recovery;
|
1374 |
|
|
int i;
|
1375 |
|
|
|
1376 |
|
|
if (0 != usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN,
|
1377 |
|
|
USBTEST_GET_RECOVERY, 0, index, 12, buffer)) {
|
1378 |
|
|
// There is work to be done
|
1379 |
|
|
buffer_index = 0;
|
1380 |
|
|
unpack_usbtest_recovery(&recovery, buffer, &buffer_index);
|
1381 |
|
|
|
1382 |
|
|
// We have an endpoint, a protocol, and a size.
|
1383 |
|
|
if (0 == recovery.endpoint) {
|
1384 |
|
|
// The target just needs a dummy reserved control message
|
1385 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_RESERVED | USB_RECIP_DEVICE, USBTEST_RESERVED_CONTROL_IN,
|
1386 |
|
|
0, 0, 0, (void*) 0);
|
1387 |
|
|
} else if (USB_ENDPOINT_XFER_BULK == recovery.protocol) {
|
1388 |
|
|
// Either we need to send some data to the target, or we need to accept some data.
|
1389 |
|
|
static unsigned char recovery_buffer[USBTEST_MAX_BULK_DATA + USBTEST_MAX_BULK_DATA_EXTRA];
|
1390 |
|
|
|
1391 |
|
|
struct usbdevfs_bulktransfer transfer;
|
1392 |
|
|
transfer.ep = recovery.endpoint;
|
1393 |
|
|
transfer.timeout = 2000; // Two seconds. Should be plenty, even for a large bulk transfer.
|
1394 |
|
|
transfer.data = recovery_buffer;
|
1395 |
|
|
if (USB_DIR_IN == (recovery.endpoint & USB_ENDPOINT_DIR_MASK)) {
|
1396 |
|
|
transfer.len = recovery.size;
|
1397 |
|
|
} else {
|
1398 |
|
|
transfer.len = 1;
|
1399 |
|
|
}
|
1400 |
|
|
errno = 0;
|
1401 |
|
|
i = ioctl(usb_master_fd, USBDEVFS_BULK, &transfer);
|
1402 |
|
|
}
|
1403 |
|
|
|
1404 |
|
|
// There is no recovery support yet for other protocols.
|
1405 |
|
|
}
|
1406 |
|
|
}
|
1407 |
|
|
|
1408 |
|
|
// Perform recovery for a local thread. This involves extracting the
|
1409 |
|
|
// recovery information from the local thread and asking the target
|
1410 |
|
|
// to take appropriate action.
|
1411 |
|
|
static void
|
1412 |
|
|
recover_local(int index)
|
1413 |
|
|
{
|
1414 |
|
|
unsigned char buffer[USBTEST_MAX_CONTROL_DATA];
|
1415 |
|
|
int buffer_index;
|
1416 |
|
|
|
1417 |
|
|
if (pool[index].running) {
|
1418 |
|
|
buffer_index = 0;
|
1419 |
|
|
pack_usbtest_recovery(&(pool[index].test.recovery), buffer, &buffer_index);
|
1420 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_PERFORM_RECOVERY,
|
1421 |
|
|
0, 0, buffer_index, (void*) buffer);
|
1422 |
|
|
}
|
1423 |
|
|
}
|
1424 |
|
|
|
1425 |
|
|
// All done, time for a clean-up on both target and host. The latter
|
1426 |
|
|
// is achieved simply by resetting the thread pool, which actually
|
1427 |
|
|
// just means resetting the counter since all the threads are blocked
|
1428 |
|
|
// waiting for the next batch.
|
1429 |
|
|
static void
|
1430 |
|
|
run_done(void)
|
1431 |
|
|
{
|
1432 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_BATCH_DONE, 0, 0, 0, (void*) NULL);
|
1433 |
|
|
local_thread_count = 0;
|
1434 |
|
|
remote_thread_count = 0;
|
1435 |
|
|
}
|
1436 |
|
|
|
1437 |
|
|
// The main routine, as invoked from Tcl. This takes a single
|
1438 |
|
|
// argument, a timeout in seconds.
|
1439 |
|
|
static int
|
1440 |
|
|
tcl_run(ClientData clientData __attribute__ ((unused)),
|
1441 |
|
|
Tcl_Interp* interp,
|
1442 |
|
|
int argc,
|
1443 |
|
|
char** argv __attribute__ ((unused)) )
|
1444 |
|
|
{
|
1445 |
|
|
struct timespec delay;
|
1446 |
|
|
int timeout;
|
1447 |
|
|
time_t start;
|
1448 |
|
|
time_t now;
|
1449 |
|
|
int i, j;
|
1450 |
|
|
unsigned char result_buf[USBTEST_MAX_CONTROL_DATA];
|
1451 |
|
|
int all_ok;
|
1452 |
|
|
|
1453 |
|
|
if (2 != argc) {
|
1454 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::_run <timeout>\"", TCL_STATIC);
|
1455 |
|
|
return TCL_ERROR;
|
1456 |
|
|
}
|
1457 |
|
|
if (TCL_OK != Tcl_GetInt(interp, argv[1], &timeout)) {
|
1458 |
|
|
Tcl_SetResult(interp, "invalid argument: timeout should be numeric", TCL_STATIC);
|
1459 |
|
|
return TCL_ERROR;
|
1460 |
|
|
}
|
1461 |
|
|
|
1462 |
|
|
VERBOSE(2, "Starting a testrun, timeout %d seconds\n", timeout);
|
1463 |
|
|
|
1464 |
|
|
// Start the tests running on the target. The target USB hardware
|
1465 |
|
|
// will not actually do anything except in response to packets
|
1466 |
|
|
// from the host, so it is better to start the target before the
|
1467 |
|
|
// local threads.
|
1468 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_START, 0, 0, 0, (void*) 0);
|
1469 |
|
|
|
1470 |
|
|
// Now the local threads can get going.
|
1471 |
|
|
current_tests_terminated = 0;
|
1472 |
|
|
pool_start();
|
1473 |
|
|
|
1474 |
|
|
// Now leave the various testing threads to do their thing until
|
1475 |
|
|
// either side believes that the batch has finished, or until the
|
1476 |
|
|
// timeout expires. Note that if one side decides that the batch
|
1477 |
|
|
// has finished but the other disagrees, that in itself indicates
|
1478 |
|
|
// a test failure of sorts.
|
1479 |
|
|
//
|
1480 |
|
|
// There is a question of polling frequency. Once a second avoids
|
1481 |
|
|
// excessive polling traffic on the USB bus, and should not impose
|
1482 |
|
|
// intolerable delays for short-duration tests.
|
1483 |
|
|
start = time(NULL);
|
1484 |
|
|
do {
|
1485 |
|
|
VERBOSE(3, "The tests are running, waiting for termination\n");
|
1486 |
|
|
delay.tv_sec = 1;
|
1487 |
|
|
delay.tv_nsec = 0;
|
1488 |
|
|
nanosleep(&delay, NULL);
|
1489 |
|
|
now = time(NULL);
|
1490 |
|
|
} while (((start + timeout) > now) && !local_batch_finished() && !remote_batch_finished());
|
1491 |
|
|
|
1492 |
|
|
VERBOSE(2, "Termination detected, time elapsed %ld\n", (long) now - start);
|
1493 |
|
|
|
1494 |
|
|
// If either side believes that testing is not complete, things
|
1495 |
|
|
// get messy. Start by setting the terminated flag. Any tests that
|
1496 |
|
|
// are actually still running happily but have not finished within
|
1497 |
|
|
// the timeout should detect this and stop.
|
1498 |
|
|
if (!local_batch_finished() || !remote_batch_finished()) {
|
1499 |
|
|
VERBOSE(2, "Testing is not yet complete, setting TERMINATED flag\n");
|
1500 |
|
|
current_tests_terminated = 1;
|
1501 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_SET_TERMINATED, 0, 0, 0, (void*) 0);
|
1502 |
|
|
// And another delay, to give threads a chance to detect the
|
1503 |
|
|
// flag's update
|
1504 |
|
|
delay.tv_sec = 1;
|
1505 |
|
|
delay.tv_nsec = 0;
|
1506 |
|
|
nanosleep(&delay, NULL);
|
1507 |
|
|
}
|
1508 |
|
|
|
1509 |
|
|
// If there is still are unfinished threads, recovery action
|
1510 |
|
|
// is needed. It is not clear whether it is better to unlock
|
1511 |
|
|
// the local threads first, or the remote threads. For now the
|
1512 |
|
|
// latter approach is taken.
|
1513 |
|
|
if (!remote_batch_finished()) {
|
1514 |
|
|
int i;
|
1515 |
|
|
VERBOSE(2, "Remote threads still running, performing remote recovery\n");
|
1516 |
|
|
for (i = 0; i < remote_thread_count; i++) {
|
1517 |
|
|
recover_remote(i);
|
1518 |
|
|
}
|
1519 |
|
|
// Allow the recovery actions to take effect
|
1520 |
|
|
delay.tv_sec = 1;
|
1521 |
|
|
delay.tv_nsec = 0;
|
1522 |
|
|
nanosleep(&delay, NULL);
|
1523 |
|
|
}
|
1524 |
|
|
|
1525 |
|
|
if (!local_batch_finished()) {
|
1526 |
|
|
int i;
|
1527 |
|
|
VERBOSE(2, "Local threads still running, performing local recovery\n");
|
1528 |
|
|
for (i = 0; i < local_thread_count; i++) {
|
1529 |
|
|
recover_local(i);
|
1530 |
|
|
}
|
1531 |
|
|
// Allow the recovery actions to take effect
|
1532 |
|
|
delay.tv_sec = 1;
|
1533 |
|
|
delay.tv_nsec = 0;
|
1534 |
|
|
nanosleep(&delay, NULL);
|
1535 |
|
|
}
|
1536 |
|
|
|
1537 |
|
|
// One last check to make sure that everything is finished. If not,
|
1538 |
|
|
// testing has broken down and it is necessary to abort.
|
1539 |
|
|
if (!local_batch_finished() || !remote_batch_finished()) {
|
1540 |
|
|
VERBOSE(2, "Giving local and remote threads another chance to finish.\n");
|
1541 |
|
|
// Allow the recovery actions to take effect
|
1542 |
|
|
delay.tv_sec = 5;
|
1543 |
|
|
delay.tv_nsec = 0;
|
1544 |
|
|
nanosleep(&delay, NULL);
|
1545 |
|
|
if (!local_batch_finished() || !remote_batch_finished()) {
|
1546 |
|
|
// OK, normality has not been restored.
|
1547 |
|
|
// It would be nice to get hold of and display any error messages.
|
1548 |
|
|
usb_abort(usb_master_fd);
|
1549 |
|
|
fprintf(stderr, "Fatal error: the host test program and the remote target are out of synch.\n");
|
1550 |
|
|
fprintf(stderr, " recovery has been attempted, without success.\n");
|
1551 |
|
|
fprintf(stderr, " USB testing cannot continue.\n");
|
1552 |
|
|
exit(EXIT_FAILURE);
|
1553 |
|
|
}
|
1554 |
|
|
}
|
1555 |
|
|
|
1556 |
|
|
VERBOSE(2, "Local and remote threads are in synch, collecting results.\n");
|
1557 |
|
|
|
1558 |
|
|
// The world is in a coherent state. Time to collect the results.
|
1559 |
|
|
// The return value of this function is a simple boolean. More
|
1560 |
|
|
// detailed results will be held in a Tcl variable as a list of
|
1561 |
|
|
// messages. It is desirable to keep both local and remote results
|
1562 |
|
|
// in order.
|
1563 |
|
|
for (i = 0; i < ((local_thread_count < remote_thread_count) ? local_thread_count : remote_thread_count); i++) {
|
1564 |
|
|
if (!pool[i].test.result_pass) {
|
1565 |
|
|
Tcl_SetVar(interp, "usbtest::results", pool[i].test.result_message,
|
1566 |
|
|
all_ok ? (TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT) : (TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT));
|
1567 |
|
|
all_ok = 0;
|
1568 |
|
|
}
|
1569 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_GET_RESULT,
|
1570 |
|
|
0, i, USBTEST_MAX_CONTROL_DATA, (void*) result_buf);
|
1571 |
|
|
if (!result_buf[0]) {
|
1572 |
|
|
Tcl_SetVar(interp, "usbtest::results", (char *)&(result_buf[1]),
|
1573 |
|
|
all_ok ? TCL_GLOBAL_ONLY : (TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT));
|
1574 |
|
|
all_ok = 0;
|
1575 |
|
|
}
|
1576 |
|
|
}
|
1577 |
|
|
for (j = i; j < local_thread_count; j++) {
|
1578 |
|
|
if (!pool[j].test.result_pass) {
|
1579 |
|
|
Tcl_SetVar(interp, "usbtest::results", pool[j].test.result_message,
|
1580 |
|
|
all_ok ? TCL_GLOBAL_ONLY : (TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT));
|
1581 |
|
|
all_ok = 0;
|
1582 |
|
|
}
|
1583 |
|
|
}
|
1584 |
|
|
for (j = i; j < remote_thread_count; j++) {
|
1585 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_GET_RESULT,
|
1586 |
|
|
0, i, USBTEST_MAX_CONTROL_DATA, (void*) result_buf);
|
1587 |
|
|
if (!result_buf[0]) {
|
1588 |
|
|
Tcl_SetVar(interp, "usbtest::results", (char *)&(result_buf[1]),
|
1589 |
|
|
all_ok ? TCL_GLOBAL_ONLY : (TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT));
|
1590 |
|
|
all_ok = 0;
|
1591 |
|
|
}
|
1592 |
|
|
}
|
1593 |
|
|
VERBOSE(2, "Overall test result %d\n", all_ok);
|
1594 |
|
|
|
1595 |
|
|
Tcl_SetResult(interp, all_ok ? "1" : "0", TCL_STATIC);
|
1596 |
|
|
|
1597 |
|
|
run_done();
|
1598 |
|
|
|
1599 |
|
|
return TCL_OK;
|
1600 |
|
|
}
|
1601 |
|
|
|
1602 |
|
|
/*}}}*/
|
1603 |
|
|
/*{{{ Set verbosity */
|
1604 |
|
|
|
1605 |
|
|
// ----------------------------------------------------------------------------
|
1606 |
|
|
// Allow Tcl scripts to control verbosity levels for both host and target
|
1607 |
|
|
static int
|
1608 |
|
|
tcl_host_verbose(ClientData clientData __attribute__ ((unused)),
|
1609 |
|
|
Tcl_Interp* interp,
|
1610 |
|
|
int argc,
|
1611 |
|
|
char** argv)
|
1612 |
|
|
{
|
1613 |
|
|
int level;
|
1614 |
|
|
|
1615 |
|
|
if (2 != argc) {
|
1616 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::host_verbose <level>\"", TCL_STATIC);
|
1617 |
|
|
return TCL_ERROR;
|
1618 |
|
|
}
|
1619 |
|
|
if (TCL_OK != Tcl_GetInt(interp, argv[1], &level)) {
|
1620 |
|
|
Tcl_SetResult(interp, "invalid argument: verbosity level should be numeric", TCL_STATIC);
|
1621 |
|
|
return TCL_ERROR;
|
1622 |
|
|
}
|
1623 |
|
|
|
1624 |
|
|
verbose = level;
|
1625 |
|
|
return TCL_OK;
|
1626 |
|
|
}
|
1627 |
|
|
|
1628 |
|
|
static int
|
1629 |
|
|
tcl_target_verbose(ClientData clientData __attribute__ ((unused)),
|
1630 |
|
|
Tcl_Interp* interp,
|
1631 |
|
|
int argc,
|
1632 |
|
|
char** argv)
|
1633 |
|
|
{
|
1634 |
|
|
int level;
|
1635 |
|
|
|
1636 |
|
|
if (2 != argc) {
|
1637 |
|
|
Tcl_SetResult(interp, "wrong # args: should be \"usbtest::target_verbose <level>\"", TCL_STATIC);
|
1638 |
|
|
return TCL_ERROR;
|
1639 |
|
|
}
|
1640 |
|
|
if (TCL_OK != Tcl_GetInt(interp, argv[1], &level)) {
|
1641 |
|
|
Tcl_SetResult(interp, "invalid argument: verbosity level should be numeric", TCL_STATIC);
|
1642 |
|
|
return TCL_ERROR;
|
1643 |
|
|
}
|
1644 |
|
|
|
1645 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_VERBOSE, level, 0, 0, NULL);
|
1646 |
|
|
usb_sync(usb_master_fd, -1);
|
1647 |
|
|
|
1648 |
|
|
return TCL_OK;
|
1649 |
|
|
}
|
1650 |
|
|
|
1651 |
|
|
/*}}}*/
|
1652 |
|
|
|
1653 |
|
|
/*}}}*/
|
1654 |
|
|
/*{{{ AppInit() */
|
1655 |
|
|
|
1656 |
|
|
// ----------------------------------------------------------------------------
|
1657 |
|
|
// Application-specific initialization. We have a bare Tcl interpreter ready
|
1658 |
|
|
// to start executing scripts that define various test cases. However some
|
1659 |
|
|
// additional functions will have to be added to the interpreter, plus
|
1660 |
|
|
// information about the various endpoints.
|
1661 |
|
|
|
1662 |
|
|
static int
|
1663 |
|
|
usbhost_appinit(Tcl_Interp* interp)
|
1664 |
|
|
{
|
1665 |
|
|
unsigned char buf[USBTEST_MAX_CONTROL_DATA];
|
1666 |
|
|
int number_of_endpoints;
|
1667 |
|
|
int i;
|
1668 |
|
|
char* location;
|
1669 |
|
|
|
1670 |
|
|
// Start by creating a usbtest namespace, for use by the various functions
|
1671 |
|
|
// and variables.
|
1672 |
|
|
if (TCL_OK != Tcl_Eval(interp,
|
1673 |
|
|
"namespace eval usbtest {\n"
|
1674 |
|
|
" variable number_of_endpoints 0\n"
|
1675 |
|
|
" array set endpoint [list]\n"
|
1676 |
|
|
"}\n")) {
|
1677 |
|
|
fprintf(stderr, "usbhost: internal error, failed to create Tcl usbtest:: namespace\n");
|
1678 |
|
|
fprintf(stderr, " Please check Tcl version (8.0b1 or later required).\n");
|
1679 |
|
|
exit(EXIT_FAILURE);
|
1680 |
|
|
}
|
1681 |
|
|
|
1682 |
|
|
// Add some information about the install path so that the
|
1683 |
|
|
// main Tcl script can find and execute test scripts.
|
1684 |
|
|
location = getenv("USBHOSTDIR");
|
1685 |
|
|
if (NULL == location) {
|
1686 |
|
|
location = USBAUXDIR;
|
1687 |
|
|
}
|
1688 |
|
|
Tcl_SetVar(interp, "usbtest::USBAUXDIR", location, TCL_GLOBAL_ONLY);
|
1689 |
|
|
|
1690 |
|
|
// Also set the verbosity level correctly
|
1691 |
|
|
Tcl_SetVar2Ex(interp, "usbtest::verbose", NULL, Tcl_NewIntObj(verbose), TCL_GLOBAL_ONLY);
|
1692 |
|
|
|
1693 |
|
|
// Next we need to know the number of endpoints, and for each
|
1694 |
|
|
// endpoint we want additional information such as type. The
|
1695 |
|
|
// results are placed in a Tcl array.
|
1696 |
|
|
usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_ENDPOINT_COUNT,
|
1697 |
|
|
0, 0, 1, buf);
|
1698 |
|
|
number_of_endpoints = buf[0];
|
1699 |
|
|
Tcl_SetVar2Ex(interp, "usbtest::endpoint_count", NULL, Tcl_NewIntObj(number_of_endpoints), TCL_GLOBAL_ONLY);
|
1700 |
|
|
|
1701 |
|
|
for (i = 0; i < number_of_endpoints; i++) {
|
1702 |
|
|
char varname[256];
|
1703 |
|
|
int result;
|
1704 |
|
|
int endpoint_min_size;
|
1705 |
|
|
int endpoint_max_size;
|
1706 |
|
|
int index;
|
1707 |
|
|
|
1708 |
|
|
memset(buf, 0, USBTEST_MAX_CONTROL_DATA);
|
1709 |
|
|
result = usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN,
|
1710 |
|
|
USBTEST_ENDPOINT_DETAILS, 0, i, USBTEST_MAX_CONTROL_DATA, buf);
|
1711 |
|
|
if (result < 13) {
|
1712 |
|
|
fprintf(stderr, "usbhost: error, received insufficient endpoint data back from the target.\n");
|
1713 |
|
|
exit(EXIT_FAILURE);
|
1714 |
|
|
}
|
1715 |
|
|
|
1716 |
|
|
// See protocol.h for the encoding used.
|
1717 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,type)", i);
|
1718 |
|
|
switch(buf[0]) {
|
1719 |
|
|
case USB_ENDPOINT_XFER_CONTROL : Tcl_SetVar(interp, varname, "control", TCL_GLOBAL_ONLY); break;
|
1720 |
|
|
case USB_ENDPOINT_XFER_ISOC : Tcl_SetVar(interp, varname, "isochronous", TCL_GLOBAL_ONLY); break;
|
1721 |
|
|
case USB_ENDPOINT_XFER_BULK : Tcl_SetVar(interp, varname, "bulk", TCL_GLOBAL_ONLY); break;
|
1722 |
|
|
case USB_ENDPOINT_XFER_INT : Tcl_SetVar(interp, varname, "interrupt", TCL_GLOBAL_ONLY); break;
|
1723 |
|
|
}
|
1724 |
|
|
|
1725 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,number)", i);
|
1726 |
|
|
Tcl_SetVar2Ex(interp, varname, NULL, Tcl_NewIntObj((int) buf[1]), TCL_GLOBAL_ONLY);
|
1727 |
|
|
|
1728 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,direction)", i);
|
1729 |
|
|
if (USB_DIR_OUT == buf[2]) {
|
1730 |
|
|
Tcl_SetVar(interp, varname, "out", TCL_GLOBAL_ONLY);
|
1731 |
|
|
} else {
|
1732 |
|
|
Tcl_SetVar(interp, varname, "in", TCL_GLOBAL_ONLY);
|
1733 |
|
|
}
|
1734 |
|
|
|
1735 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,max_in_padding)", i);
|
1736 |
|
|
Tcl_SetVar2Ex(interp, varname, NULL, Tcl_NewIntObj((int) buf[3]), TCL_GLOBAL_ONLY);
|
1737 |
|
|
|
1738 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,min_size)", i);
|
1739 |
|
|
index = 4;
|
1740 |
|
|
endpoint_min_size = unpack_int(buf, &index);
|
1741 |
|
|
Tcl_SetVar2Ex(interp, varname, NULL, Tcl_NewIntObj(endpoint_min_size), TCL_GLOBAL_ONLY);
|
1742 |
|
|
|
1743 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,max_size)", i);
|
1744 |
|
|
endpoint_max_size = unpack_int(buf, &index);
|
1745 |
|
|
if (USB_ENDPOINT_XFER_CONTROL == buf[0]) {
|
1746 |
|
|
if (endpoint_max_size > USBTEST_MAX_CONTROL_DATA) {
|
1747 |
|
|
endpoint_max_size = USBTEST_MAX_CONTROL_DATA;
|
1748 |
|
|
}
|
1749 |
|
|
} else {
|
1750 |
|
|
if ((-1 == endpoint_max_size) || (endpoint_max_size > USBTEST_MAX_BULK_DATA)) {
|
1751 |
|
|
endpoint_max_size = USBTEST_MAX_BULK_DATA;
|
1752 |
|
|
}
|
1753 |
|
|
}
|
1754 |
|
|
Tcl_SetVar2Ex(interp, varname, NULL, Tcl_NewIntObj(endpoint_max_size), TCL_GLOBAL_ONLY);
|
1755 |
|
|
|
1756 |
|
|
sprintf(varname, "usbtest::endpoint_data(%d,devtab)", i);
|
1757 |
|
|
Tcl_SetVar(interp, varname, (char*) &(buf[12]), TCL_GLOBAL_ONLY);
|
1758 |
|
|
|
1759 |
|
|
// Perform any additional endpoint-specific initialization to make
|
1760 |
|
|
// sure host and target can actually communicate via this endpoint.
|
1761 |
|
|
switch(buf[0]) {
|
1762 |
|
|
case USB_ENDPOINT_XFER_CONTROL :
|
1763 |
|
|
{
|
1764 |
|
|
usb_initialise_control_endpoint(endpoint_min_size, endpoint_max_size);
|
1765 |
|
|
break;
|
1766 |
|
|
}
|
1767 |
|
|
case USB_ENDPOINT_XFER_ISOC :
|
1768 |
|
|
{
|
1769 |
|
|
if (USB_DIR_OUT == buf[2]) {
|
1770 |
|
|
usb_initialise_isochronous_out_endpoint(buf[1], endpoint_min_size, endpoint_max_size);
|
1771 |
|
|
} else {
|
1772 |
|
|
usb_initialise_isochronous_in_endpoint(buf[1], endpoint_min_size, endpoint_max_size);
|
1773 |
|
|
}
|
1774 |
|
|
break;
|
1775 |
|
|
}
|
1776 |
|
|
case USB_ENDPOINT_XFER_BULK :
|
1777 |
|
|
{
|
1778 |
|
|
if (USB_DIR_OUT == buf[2]) {
|
1779 |
|
|
usb_initialise_bulk_out_endpoint(buf[1], endpoint_min_size, endpoint_max_size);
|
1780 |
|
|
} else {
|
1781 |
|
|
usb_initialise_bulk_in_endpoint(buf[1], endpoint_min_size, endpoint_max_size, buf[3]);
|
1782 |
|
|
}
|
1783 |
|
|
|
1784 |
|
|
break;
|
1785 |
|
|
}
|
1786 |
|
|
case USB_ENDPOINT_XFER_INT :
|
1787 |
|
|
{
|
1788 |
|
|
if (USB_DIR_OUT == buf[2]) {
|
1789 |
|
|
usb_initialise_interrupt_out_endpoint(buf[1], endpoint_min_size, endpoint_max_size);
|
1790 |
|
|
} else {
|
1791 |
|
|
usb_initialise_interrupt_in_endpoint(buf[1], endpoint_min_size, endpoint_max_size);
|
1792 |
|
|
}
|
1793 |
|
|
break;
|
1794 |
|
|
}
|
1795 |
|
|
}
|
1796 |
|
|
}
|
1797 |
|
|
|
1798 |
|
|
// Register appropriate commands with the Tcl interpreter
|
1799 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_pass", &tcl_target_pass, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1800 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_pass_exit", &tcl_target_pass_exit, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1801 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_fail", &tcl_target_fail, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1802 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_fail_exit", &tcl_target_fail_exit, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1803 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_abort", &tcl_target_abort, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1804 |
|
|
Tcl_CreateCommand(interp, "usbtest::_test_bulk", &tcl_test_bulk, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1805 |
|
|
Tcl_CreateCommand(interp, "usbtest::_test_control_in", &tcl_test_control_in, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1806 |
|
|
Tcl_CreateCommand(interp, "usbtest::_cancel", &tcl_cancel, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1807 |
|
|
Tcl_CreateCommand(interp, "usbtest::_run", &tcl_run, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1808 |
|
|
Tcl_CreateCommand(interp, "usbtest::host_verbose", &tcl_host_verbose, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1809 |
|
|
Tcl_CreateCommand(interp, "usbtest::target_verbose", &tcl_target_verbose, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL);
|
1810 |
|
|
|
1811 |
|
|
return TCL_OK;
|
1812 |
|
|
}
|
1813 |
|
|
|
1814 |
|
|
/*}}}*/
|
1815 |
|
|
/*{{{ main() */
|
1816 |
|
|
|
1817 |
|
|
// ----------------------------------------------------------------------------
|
1818 |
|
|
// System start-up. After argument processing this code checks that
|
1819 |
|
|
// there is a suitable USB target attached - if not then there is no
|
1820 |
|
|
// point in proceeding. Otherwise further initialization is performed
|
1821 |
|
|
// and then control is passed to a Tcl interpreter.
|
1822 |
|
|
|
1823 |
|
|
static void
|
1824 |
|
|
usage(void)
|
1825 |
|
|
{
|
1826 |
|
|
printf("usbhost: usage, usbhost [-V|--verbose] [-v|--version] [-h|--help] <test> [args]\n");
|
1827 |
|
|
printf(" -V, --verbose Make the host-side output additional information\n");
|
1828 |
|
|
printf(" during test runs. This argument can be repeated to\n");
|
1829 |
|
|
printf(" increase verbosity.\n");
|
1830 |
|
|
printf(" -v, --version Output version information for usbhost.\n");
|
1831 |
|
|
printf(" -h, --help Output this help information.\n");
|
1832 |
|
|
printf(" <test> The name of a USB test case, for example list.tcl\n");
|
1833 |
|
|
printf(" [args] Optional additional arguments for the testcase.\n");
|
1834 |
|
|
exit(0);
|
1835 |
|
|
}
|
1836 |
|
|
|
1837 |
|
|
static void
|
1838 |
|
|
version(void)
|
1839 |
|
|
{
|
1840 |
|
|
printf("usbhost: version %s\n", USBHOST_VERSION);
|
1841 |
|
|
printf(" : built from USB slave package version %s\n", PKGVERSION);
|
1842 |
|
|
printf(" : support files installed in %s\n", USBAUXDIR);
|
1843 |
|
|
exit(0);
|
1844 |
|
|
}
|
1845 |
|
|
|
1846 |
|
|
int
|
1847 |
|
|
main(int argc, char** argv)
|
1848 |
|
|
{
|
1849 |
|
|
char* interpreter = argv[0];
|
1850 |
|
|
char** new_argv;
|
1851 |
|
|
char path[_POSIX_PATH_MAX];
|
1852 |
|
|
char* location;
|
1853 |
|
|
int i;
|
1854 |
|
|
|
1855 |
|
|
// Argument processing
|
1856 |
|
|
for (i = 1; i < argc; i++) {
|
1857 |
|
|
if ((0 == strcmp("-h", argv[i])) || (0 == strcmp("-H", argv[i])) || (0 == strcmp("--help", argv[i]))) {
|
1858 |
|
|
usage();
|
1859 |
|
|
}
|
1860 |
|
|
if ((0 == strcmp("-v", argv[i])) || (0 == strcmp("--version", argv[i]))) {
|
1861 |
|
|
version();
|
1862 |
|
|
}
|
1863 |
|
|
if ((0 == strcmp("-V", argv[i])) || (0 == strcmp("--verbose", argv[i]))) {
|
1864 |
|
|
verbose++;
|
1865 |
|
|
continue;
|
1866 |
|
|
}
|
1867 |
|
|
|
1868 |
|
|
// The first unrecognised argument should correspond to the test script.
|
1869 |
|
|
break;
|
1870 |
|
|
}
|
1871 |
|
|
argc = (argc - i) + 1;
|
1872 |
|
|
argv = (argv + i) - 1;
|
1873 |
|
|
|
1874 |
|
|
if (1 == argc) {
|
1875 |
|
|
fprintf(stderr, "usbhost: at least one test script must be specified on the command line.\n");
|
1876 |
|
|
exit(EXIT_FAILURE);
|
1877 |
|
|
}
|
1878 |
|
|
|
1879 |
|
|
usb_master_fd = usb_open_device();
|
1880 |
|
|
if (-1 == usb_master_fd) {
|
1881 |
|
|
return EXIT_FAILURE;
|
1882 |
|
|
}
|
1883 |
|
|
|
1884 |
|
|
// There is a valid USB target. Initialize the pool of threads etc.
|
1885 |
|
|
pool_initialize();
|
1886 |
|
|
|
1887 |
|
|
// Now start a Tcl interpreter. Tcl_Main() will interpret the
|
1888 |
|
|
// first argument as the name of a Tcl script to execute,
|
1889 |
|
|
// i.e. usbhost.tcl. This can be found in the install tree,
|
1890 |
|
|
// but during development it is inconvenient to run
|
1891 |
|
|
// "make install" every time the Tcl script is edited so an
|
1892 |
|
|
// environment variable can be used to override the location.
|
1893 |
|
|
new_argv = malloc((argc + 2) * sizeof(char*));
|
1894 |
|
|
if (NULL == new_argv) {
|
1895 |
|
|
fprintf(stderr, "usbhost: internal error, out of memory.\n");
|
1896 |
|
|
exit(EXIT_FAILURE);
|
1897 |
|
|
}
|
1898 |
|
|
new_argv[0] = interpreter;
|
1899 |
|
|
|
1900 |
|
|
location = getenv("USBHOSTDIR");
|
1901 |
|
|
if (NULL == location) {
|
1902 |
|
|
location = USBAUXDIR;
|
1903 |
|
|
}
|
1904 |
|
|
snprintf(path, _POSIX_PATH_MAX, "%s/usbhost.tcl", location);
|
1905 |
|
|
if (0 != access(path, R_OK)) {
|
1906 |
|
|
fprintf(stderr, "usbhost: cannot find or access required Tcl script\n");
|
1907 |
|
|
fprintf(stderr, " : %s\n", path);
|
1908 |
|
|
exit(EXIT_FAILURE);
|
1909 |
|
|
}
|
1910 |
|
|
new_argv[1] = path;
|
1911 |
|
|
|
1912 |
|
|
for (i = 1; i < argc; i++) {
|
1913 |
|
|
new_argv[i+1] = argv[i];
|
1914 |
|
|
}
|
1915 |
|
|
new_argv[i+1] = NULL;
|
1916 |
|
|
|
1917 |
|
|
Tcl_Main(i+1, new_argv, &usbhost_appinit);
|
1918 |
|
|
|
1919 |
|
|
return EXIT_SUCCESS;
|
1920 |
|
|
}
|
1921 |
|
|
|
1922 |
|
|
/*}}}*/
|