Subversion Repositories openrisc

/*{{{  Banner                                                   */

//=================================================================

//

//        host.c

//

//        USB testing - host-side

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     bartv

// Date:          2001-07-04

//####DESCRIPTIONEND####

//==========================================================================

// The overall architecture is as follows.

//

// The target hardware runs a special application which provides a

// particular type of USB application, "Red Hat eCos USB testing".

// This will not be recognised by any device driver, so the Linux

// kernel will pretty much ignore the device (other host OS's are not

// considered at this time).

//

// This program is the only supported way to interact with that service.

// It acts as an extended Tcl interpreter, providing a number of new

// Tcl commands for interacting with the target. All test cases can

// then be written as Tcl scripts which invoke a series of these commands.

// These Tcl commands operate essentially though the LINUX usb devfs

// service which allows ordinary application code to perform USB operations

// via ioctl()'s.

/*}}}*/

/*{{{  #include's                                               */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <limits.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <time.h>

#include <pthread.h>

#include <semaphore.h>

// Avoid compatibility problems with Tcl 8.4 vs. earlier

#define USE_NON_CONST

#include <tcl.h>

#include <linux/usb.h>

#include <linux/usbdevice_fs.h>

#include "../tests/protocol.h"

/*}}}*/

/*{{{  Statics                                                  */

// ----------------------------------------------------------------------------

// Statics.

// Has the current batch of tests actually terminated? This flag is

// checked by the various test handlers at appropriate intervals, and

// helps to handle the case where one of the side has terminated early

// because an error has been detected.

static int          current_tests_terminated = 0;

// The next local thread to be allocated for testing. This variable can also

// be used to find out how many threads are involved in the current test.

// This counter should always be reset to 0 at the end of every test run.

static int          local_thread_count      = 0;

// A similar counter for remote threads.

static int          remote_thread_count     = 0;

// A file handle for manipulating the USB device at a low level

static int          usb_master_fd  = -1;

/*}}}*/

/*{{{  Logging                                                  */

// ----------------------------------------------------------------------------

// The user can provide one or more -V/--verbose arguments to increase

// the amount of output generated.

static int verbose = 0;

#define VERBOSE(_level_, _format_, _args_...)   \

    do {                                        \

        if (verbose >= _level_) {               \

            printf(_format_, ## _args_);        \

        }                                       \

    } while (0);

/*}}}*/

/*{{{  Low-level USB access                                     */

// ----------------------------------------------------------------------------

// Low-level access to a USB device.

//

// The various ioctl() calls require a file handle which corresponds to one

// of the /proc/bus/usb/<abc>/<def> entries. <abc> is a bus number,

// typically 001 or 001, and <def> is a device number on that bus,

// e.g. 003. Figuring out <abc> and <def> requires scanning

// /proc/bus/usb/devices, which is a somewhat complicated text file.

//

// This is all somewhat vulnerable to incompatible changes in the

// Linux kernel, specifically the implementation of the /proc/bus/usb.

// An alternative approach would be to write a new Linux device driver

// and interact with that, but that approach is vulnerable to any

// internal kernel API changes affecting USB device drivers.

// How to access USB devices from userland

#define USB_ROOT        "/proc/bus/usb/"

// How to identify the eCos test case

#define PRODUCT_STRING    "Red Hat eCos USB test"

// Scan through /proc/bus/usb/devices looking for an entry that

// matches what we are after, specifically a line

//   S:  Product=Red Hat eCos USB testcase

// The required information can then be obtained from the previous

// line:

//   T:  Bus=<abc> ... Dev#= <def> ...

//

// Of course the T: line is going to come first, so it is necessary

// to keep track of the current bus and device numbers.

//

// Note: this code is duplicated in usbchmod.c. Any changes here

// should be propagated. For now the routine is too small to warrant

// a separate source file.

static int

usb_scan_devices(int* bus, int* dev)

{

    FILE*       devs_file;

    int         current_bus     = -1;

    int         current_dev     = -1;

    int         ch;

    *bus = -1;

    *dev = -1;

    VERBOSE(1, "Searching " USB_ROOT "devices for the eCos USB test code\n");

    devs_file = fopen(USB_ROOT "devices", "r");

    if (NULL == devs_file) {

        fprintf(stderr, "usbhost: error, unable to access " USB_ROOT "devices\n");

        return 0;

    }

    ch = getc(devs_file);

    while (EOF != ch) {

        if ('T' == ch) {

            if (2 !=fscanf(devs_file, ":  Bus=%d %*[^D\n]Dev#=%d", &current_bus, &current_dev)) {

                current_bus = -1;

                current_dev = -1;

            }

        } else if ('S' == ch) {

            int start = 0, end = 0;

            if (EOF != fscanf(devs_file, ":  Product=%n" PRODUCT_STRING "%n", &start, &end)) {

                if (start < end) {

                    *bus = current_bus;

                    *dev = current_dev;

                    break;

                }

            }

        }

        // Move to the end of the current line.

        do {

            ch = getc(devs_file);

        } while ((EOF != ch) && ('\n' != ch));

        if (EOF != ch) {

            ch = getc(devs_file);

        }

    }

    fclose(devs_file);

    if ((-1 != *bus) && (-1 != *dev)) {

        VERBOSE(1, "Found eCos USB test code on bus %d, device %d\n", *bus, *dev);

        return 1;

    }

    fprintf(stderr, "usbhost: error, failed to find a USB device \"" PRODUCT_STRING "\"\n");

    return 0;

}

// Actually open the USB device, allowing subsequent ioctl() operations.

//

// Typically /proc/bus/usb/... will not allow ordinary applications

// to perform ioctl()'s. Instead root privileges are required. To work

// around this there is a little utility usbchmod, installed suid,

// which can be used to get access to the raw device.

static int

usb_open_device(void)

{

    char devname[_POSIX_PATH_MAX];

    static int  bus = -1;

    static int  dev = -1;

    int         result;

    if ((-1 == bus) || (-1 == dev)) {

        if (!usb_scan_devices(&bus, &dev)) {

            return -1;

        }

    }

    if (_POSIX_PATH_MAX == snprintf(devname, _POSIX_PATH_MAX, USB_ROOT "%03d/%03d", bus, dev)) {

        fprintf(stderr, "usbhost: internal error, buffer overflow\n");

        exit(EXIT_FAILURE);

    }

    VERBOSE(1, "Attempting to access USB target via %s\n", devname);

    result = open(devname, O_RDWR);

    if (-1 == result) {

        // Check for access right problems. If so, try to work around them

        // by invoking usbchmod. Always look for this in the install tree,

        // since it is only that version which is likely to have been

        // chown'ed and chmod'ed to be suid root.

        if (EACCES == errno) {

            char command_name[_POSIX_PATH_MAX];

            VERBOSE(1, "Insufficient access to USB target, running usbchmod\n");

            if (_POSIX_PATH_MAX == snprintf(command_name, _POSIX_PATH_MAX, "%s/usbchmod %d %d", USBAUXDIR, bus, dev)) {

                fprintf(stderr, "usbhost: internal error, buffer overflow\n");

                exit(EXIT_FAILURE);

            }

            (void) system(command_name);

            result = open(devname, O_RDWR);

        }

    }

    if (-1 == result) {

        fprintf(stderr, "usbhost: error, failed to open \"%s\", errno %d\n", devname, errno);

    }

    VERBOSE(1, "USB device now accessible via file descriptor %d\n", result);

    // Also perform a set-configuration call, to avoid warnings from

    // the Linux kernel. Target-side testing is always configuration 1

    // because only a single configuration is supported.

    (void) ioctl(result, USBDEVFS_SETCONFIGURATION, 1);

    return result;

}

// Exchange a control message with the host. The return value should

// be 0, or a small positive number indicating the actual number of

// bytes received which may be less than requested.

//

// There appear to be problems with some hosts, manifesting itself as

// an inability to send control messages that involve additional data

// from host->target. These problems are not yet well-understood. For

// now the workaround is to send multiple packets, each with up to

// four bytes encoded in the index and length fields.

static int

usb_control_message(int fd, int request_type, int request, int value, int index, int length, void* data)

{

    struct usbdevfs_ctrltransfer        transfer;

    int         result = 0;

    VERBOSE(3, "usb_control_message, request %02x, len %d\n", request, length);

    if (length > USBTEST_MAX_CONTROL_DATA) {

        fprintf(stderr, "usbhost: internal error, control message involves too much data.\n");

        exit(EXIT_FAILURE);

    }

#if 1

    // Workaround - send additional data in the index and length fields.

    if ((length > 0) && (USB_DIR_OUT == (USB_ENDPOINT_DIR_MASK & request_type))) {

        int i;

        unsigned char*  buf = (unsigned char*) data;

        for (i = 0; i < length; i+= 4) {

            int this_len = length - 1;

            int ioctl_result;

            transfer.requesttype    = USB_TYPE_CLASS | USB_RECIP_DEVICE;

            if (this_len > 4) {

                this_len = 4;

            }

            switch (this_len) {

              case 1: transfer.request  = USBTEST_CONTROL_DATA1; break;

              case 2: transfer.request  = USBTEST_CONTROL_DATA2; break;

              case 3: transfer.request  = USBTEST_CONTROL_DATA3; break;

              case 4: transfer.request  = USBTEST_CONTROL_DATA4; break;

              default:

                fprintf(stderr, "usbhost: internal error, confusion about transfer length.\n");

                exit(EXIT_FAILURE);

            }

            transfer.value      = (buf[i]   << 8) | buf[i+1];   // Possible read beyond end of buffer,

            transfer.index      = (buf[i+2] << 8) | buf[i+3];   // but not worth worrying about.

            transfer.length     = 0;

            transfer.timeout    = 10 * 1000; // ten seconds, the target should always accept data faster than this.

            transfer.data       = NULL;

            // This is too strict, deciding what to do about errors should be

            // handled by higher-level code. However it will do for now.

            ioctl_result = ioctl(fd, USBDEVFS_CONTROL, &transfer);

            if (0 != ioctl_result) {

                fprintf(stderr, "usbhost: error, failed to send control message (data) to target.\n");

                exit(EXIT_FAILURE);

            }

        }

        // There is no more data to be transferred.

        length = 0;

    }

#endif    

    transfer.requesttype        = request_type;

    transfer.request            = request;

    transfer.value              = value;

    transfer.index              = index;

    transfer.length             = length;

    transfer.timeout            = 10000;

    transfer.data               = data;

    result = ioctl(fd, USBDEVFS_CONTROL, &transfer);

    return result;

}

// A variant of the above which can be called when the target should always respond

// correctly. This can be used for class control messages.

static int

usb_reliable_control_message(int fd, int request_type, int request, int value, int index, int length, void* data)

{

    int result = usb_control_message(fd, request_type, request, value, index, length, data);

    if (-1 == result) {

        fprintf(stderr, "usbhost: error, failed to send control message %02x to target.\n", request);

        fprintf(stderr, "       : errno %d (%s)\n", errno, strerror(errno));

        exit(EXIT_FAILURE);

    }

    return result;

}

// Either send or receive a single bulk message. The top bit of the endpoint

// number indicates the direction.

static int

usb_bulk_message(int fd, int endpoint, unsigned char* buffer, int length)

{

    struct  usbdevfs_bulktransfer    transfer;

    int     result;

    transfer.ep         = endpoint;

    transfer.len        = length;

    transfer.timeout    = 60 * 60 * 1000;

    // An hour. These operations should not time out because that

    // leaves the system in a confused state. Instead there is

    // higher-level recovery code that should ensure the operation

    // really does complete, and the return value here is used

    // by the calling code to determine whether the operation

    // was successful or whether there was an error and the recovery

    // code was invoked.

    transfer.data       = buffer;

    errno               = 0;

    result = ioctl(fd, USBDEVFS_BULK, &transfer);

    return result;

}

// Synchronise with the target. This can be used after the host has sent a request that

// may take a bit of time, e.g. it may involve waking up a thread. The host will send

// synch requests at regular intervals, until the target is ready.

//

// The limit argument can be used to avoid locking up. -1 means loop forever, otherwise

// it means that many iterations of 100ms apiece.

static int

usb_sync(int fd, int limit)

{

    unsigned char   buf[1];

    struct timespec delay;

    int             loops   = 0;

    int             result  = 0;

    VERBOSE(2, "Synchronizing with target\n");

    while (1) {

        buf[0]  = 0;

        usb_reliable_control_message(fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN, USBTEST_SYNCH, 0, 0, 1, buf);

        if (buf[0]) {

            result = 1;

            break;

        } else {

            if ((-1 != limit) && (++loops > limit)) {

                break;

            } else {

                VERBOSE(3, "Not yet synchronized, sleeping\n");

                delay.tv_sec    = 0;

                delay.tv_nsec   = 100000000;    // 100 ms

                nanosleep(&delay, NULL);

            }

        }

    }

    VERBOSE(2, "%s\n", result ? "Synchronized" : "Not synchronized");

    return result;

}

// Abort the target. Things seem to be completely messed up and there is no easy

// way to restore sanity to both target and host.

static void

usb_abort(int fd)

{

    VERBOSE(2, "Target-side abort operation invoked\n");

    usb_reliable_control_message(fd, USB_TYPE_CLASS | USB_RECIP_DEVICE, USBTEST_ABORT, 0, 0, 0, (void*)0);

}

/*}}}*/

/*{{{  Initialise endpoints                                     */

// ----------------------------------------------------------------------------

// On power-up some endpoints may not be in a sensible state. For example,

// with the SA11x0 the hardware may start accepting bulk OUT transfers

// before the target-side software has started a receive operation,

// so if the host sends a bulk packet before the target is ready then

// things get messy. This is especially troublesome if the target-side

// attempts any diagnostic output because of verbosity.

//

// This code loops through the various endpoints and makes sure that

// they are all in a reasonable state, before any real tests get run

// That means known hardware flaws do not show up as test failures,

// but of course they are still documented and application software

// will have to do the right thing.

static void

usb_initialise_control_endpoint(int min_size, int max_size)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

static void

usb_initialise_isochronous_in_endpoint(int number, int min_size, int max_size)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

static void

usb_initialise_isochronous_out_endpoint(int number, int min_size, int max_size)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

static void

usb_initialise_bulk_in_endpoint(int number, int min_size, int max_size, int padding)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

static void

usb_initialise_bulk_out_endpoint(int number, int min_size, int max_size)

{

    char buf[1];

    // On the SA1110 the hardware comes up with a bogus default value,

    // causing the hardware to accept packets before the software has

    // set up DMA or in any way prepared for incoming data. This is

    // a problem. It is worked around by making the target receive

    // a single packet, sending that packet, and then performing a

    // sync.

    VERBOSE(2, "Performing bulk OUT initialization on endpoint %d\n", number);

    usb_reliable_control_message(usb_master_fd, USB_TYPE_CLASS | USB_RECIP_DEVICE | USB_DIR_IN,

                                 USBTEST_INIT_BULK_OUT, number, 0, 0, (void*) 0);

    usb_bulk_message(usb_master_fd, number, buf, 1);

    usb_sync(usb_master_fd, 10);

}

static void

usb_initialise_interrupt_in_endpoint(int number, int min_size, int max_size)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

static void

usb_initialise_interrupt_out_endpoint(int number, int min_size, int max_size)

{

    // At this time there are no known problems on any hardware

    // that would need to be addressed

}

/*}}}*/

/*{{{  Host/target common code                                  */

#define HOST

#include "../tests/common.c"

/*}}}*/

/*{{{  The test cases themselves                                */

/*{{{  UsbTest definition                                       */

// ----------------------------------------------------------------------------

// All the data associated with a single test.

typedef struct UsbTest {

    // A "unique" identifier to make verbose output easier to understand.

    int                 id;

    // Which file descriptor should be used to access USB.

    int                 fd;

    // Which test should be run.

    usbtest             which_test;

    // Test-specific details.

    union {

        UsbTest_Bulk        bulk;

        UsbTest_ControlIn   control_in;

    } test_params;

    // How to recover from any problems. Specifically, what kind of message

    // could the target send or receive that would unlock the thread on this

    // side.

    UsbTest_Recovery    recovery;

    int                 result_pass;

    char                result_message[USBTEST_MAX_MESSAGE];

    unsigned char       buffer[USBTEST_MAX_BULK_DATA + USBTEST_MAX_BULK_DATA_EXTRA];

} UsbTest;

// Reset the information in a given test. This is used by the pool allocation

// code. The data union is left alone, filling in the appropriate union

// member is left to other code.

static void

reset_usbtest(UsbTest* test)

{

    static int next_id = 1;

    test->id                    = next_id++;

    test->which_test            = usbtest_invalid;

    usbtest_recovery_reset(&(test->recovery));

    test->result_pass           = 0;

    test->result_message[0]     = '\0';

}

/*}}}*/

/*{{{  bulk OUT                                                 */

static void

run_test_bulk_out(UsbTest* test)

{

    unsigned char*  buf     = test->buffer;

    int             i;

    VERBOSE(1, "Starting test %d, bulk OUT on endpoint %d\n", test->id, test->test_params.bulk.endpoint);

    for (i = 0; i < test->test_params.bulk.number_packets; i++) {

        int transferred;

        int packet_size = test->test_params.bulk.tx_size;

        test->recovery.endpoint     = test->test_params.bulk.endpoint;

        test->recovery.protocol     = USB_ENDPOINT_XFER_BULK;

        test->recovery.size         = packet_size;

        usbtest_fill_buffer(&(test->test_params.bulk.data), buf, packet_size);

        if (verbose < 3) {

            VERBOSE(2, "Bulk OUT test %d: iteration %d, packet size %d\n", test->id, i, packet_size);

        } else {

            // Output the first 32 bytes of data as well.

            char msg[256];

            int  index;

            int  j;

            index = snprintf(msg, 255, "Bulk OUT test %d: iteration %d, packet size %d\n    Data %s:",

                             test->id, i, packet_size,

                             (usbtestdata_none == test->test_params.bulk.data.format) ? "(uninitialized)" : "");

            for (j = 0; ((j + 3) < packet_size) && (j < 32); j+= 4) {

                index += snprintf(msg+index, 255-index, " %02x%02x%02x%02x",

                                  buf[j], buf[j+1], buf[j+2], buf[j+3]);

            }

            if (j < 32) {

                index += snprintf(msg+index, 255-index, " ");

                for ( ; j < packet_size; j++) {

                    index += snprintf(msg+index, 255-index, "%02x", buf[j]);

                }

            }

            VERBOSE(3, "%s\n", msg);

        }

        transferred = usb_bulk_message(test->fd, test->test_params.bulk.endpoint, buf, packet_size);

        // Has this test run been aborted for some reason?

        if (current_tests_terminated) {

            VERBOSE(2, "Bulk OUT test %d: iteration %d, termination detected\n", test->id, i);

            test->result_pass = 0;

            snprintf(test->result_message, USBTEST_MAX_MESSAGE,

                     "Host, bulk OUT transfer on endpoint %d: aborted after %d iterations\n",

                     test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, i);

            return;

        }

        // If an error occurred, abort this run.

        if (-1 == transferred) {

            char    errno_buf[USBTEST_MAX_MESSAGE];

            test->result_pass  = 0;

            snprintf(test->result_message, USBTEST_MAX_MESSAGE,

                     "Host, bulk OUT transfer on endpoint %d : host ioctl() system call failed\n    errno %d (%s)",

                     test->test_params.bulk.endpoint & USB_ENDPOINT_NUMBER_MASK, errno,

                     strerror_r(errno, errno_buf, USBTEST_MAX_MESSAGE));

            VERBOSE(2, "Bulk OUT test %d: iteration %d, error:\n    %s\n", test->id, i, test->result_message);

            break;

        }

        if (0 != test->test_params.bulk.tx_delay) {

            struct timespec delay;

            VERBOSE(2, "Bulk OUT test %d: iteration %d, sleeping for %d nanoseconds\n", test->id, \

                    i, test->test_params.bulk.tx_delay);

            // Note that nanosleep() can return early due to incoming signals,

            // with the unelapsed time returned in a second argument. This

            // allows for a retry loop. In practice this does not seem

            // worthwhile, the delays are approximate anyway.

            delay.tv_sec  = test->test_params.bulk.tx_delay / 1000000000;

            delay.tv_nsec = test->test_params.bulk.tx_delay % 1000000000;

            nanosleep(&delay, NULL);

        }

        // Now move on to the next transfer

        USBTEST_BULK_NEXT(test->test_params.bulk);

    }

    // If all the packets have been transferred this test has passed.

    if (i >= test->test_params.bulk.number_packets) {

        test->result_pass   = 1;

    }

    VERBOSE(1, "Test %d bulk OUT on endpoint %d, result %d\n", test->id, test->test_params.bulk.endpoint, test->result_pass);

}

/*}}}*/

/*{{{  bulk IN                                                  */

static void

run_test_bulk_in(UsbTest* test)

{

    unsigned char*  buf     = test->buffer;

    int             i;