eCos Reference Manual
Prev |  | Next

# Receiving Data from the Host

## Name

`usbs_start_rx_buffer` -- Receiving Data from the Host

## Synopsis

    #include <cyg/io/usb/usbs.h>

``void usbs_start_rx_buffer`(usbs_rx_endpoint* ep, unsigned char* buffer, int length, void (*)(void*,int) complete_fn, void * complete_data);`

``void usbs_start_rx`(usbs_rx_endpoint* ep);`

## `Description`

`usbs_start_rx_buffer` is a USB-specific function to accept a transfer from host to peripheral. It can be used for bulk, interrupt or isochronous transfers, but not for control messages. Instead those involve manipulating the `usbs_control_endpoint` data structure directly. The function takes five arguments:

1. The first argument identifies the specific endpoint that should be used. Different USB devices will support different sets of endpoints and the device driver will provide appropriate data structures. The device driver's documentation should be consulted for details of which endpoints are available.

2. The `buffer` and `length` arguments control the actual transfer. USB device drivers are not expected to perform any buffering or to support partial transfers, so the length specified should correspond to the maximum transfer that is currently possible and the buffer should be at least this large. For isochronous transfers the USB specification imposes an upper bound of 1023 bytes, and a smaller limit may be set in the enumeration data. Interrupt transfers are similarly straightforward with an upper bound of 64 bytes, or less as per the enumeration data. Bulk transfers are more complicated because they can involve multiple 64-byte packets plus a terminating packet of less than 64 bytes, so there is no predefined limit on the transfer size. Instead it is left to higher-level protocols to specify an appropriate upper bound.

   One technique that may work for bulk transfers is to exploit the fact that such transfers happen in 64-byte packets: it may be possible to receive an initial 64 bytes, corresponding to the first packet in the transfer; these 64 bytes can then be examined to determine the total transfer size, and the remaining data can be transferred in another receive operation. This technique is not guaranteed to work with all USB hardware. Also, if the delay between accepting the first packet and the remainder of the transfer is excessive then this could cause timeout problems for the host-side software. For these reasons this technique should be avoided.

3. `usbs_start_rx_buffer` is non-blocking. It merely starts the receive operation, and does not wait for completion. At some later point the USB device driver will invoke the completion function parameter with two arguments: the completion data defined by the last parameter and a result field. A result >= `0` indicates a successful transfer of that many bytes, which may be less than the upper bound imposed by the `length` argument. A result < `0` indicates an error. The most likely errors are `-EPIPE` to indicate that the connection between the host and the target has been broken, and `-EAGAIN` for when the endpoint has been halted. Specific USB device drivers may specify additional error conditions.

The normal sequence of events is that the USB device driver will update the appropriate hardware registers. At some point after that the host will attempt to send data by transmitting an OUT token followed by a data packet, and since a receive operation is now in progress the data will be accepted and ACK'd. If there were no receive operation then the peripheral would instead generate a NAK. The USB hardware will generate an interrupt once the whole packet has been received, and the USB device driver will service this interrupt and arrange for a DSR to be called. Isochronous and interrupt transfers involve just a single packet. However, bulk transfers may involve multiple packets so the device driver has to check whether the packet was a full 64 bytes or whether it was a terminating packet of less than this. When the device driver DSR detects a complete transfer it will inform higher-level code by invoking the supplied completion function.

This means that the completion function will normally be invoked by a DSR and not in thread context - although some USB device drivers may have a different implementation. Therefore the completion function is restricted in what it can do. In particular it must not make any calls that will or may block such as locking a mutex or allocating memory. The kernel documentation should be consulted for more details of DSR's and interrupt handling generally.

It is possible that the completion function will be invoked before `usbs_start_rx_buffer` returns. Such an event would be unusual because the transfer cannot happen until the next time the host tries to send data to this peripheral, but it may happen if for example another interrupt happens and a higher priority thread is scheduled to run. Also, if the endpoint is currently halted then the completion function will be invoked immediately with `-EAGAIN`: typically this will happen in the current thread rather than in a separate DSR. The completion function is allowed to start another transfer immediately by calling `usbs_start_rx_buffer` again.

USB device drivers are not expected to perform any locking. It is the responsibility of higher-level code to ensure that there is only one receive operation for a given endpoint in progress at any one time. If there are concurrent calls to `usbs_start_rx_buffer` then the resulting behaviour is undefined. For typical USB applications this does not present any problems, because only one piece of code will access a given endpoint at any particular time.

The following code fragment illustrates a very simple use of `usbs_start_rx_buffer` to implement a blocking receive, using a semaphore to synchronise between the foreground thread and the DSR. For a simple example like this no completion data is needed.

    static int error_code = 0;
    static cyg_sem_t completion_wait;

    static void
    completion_fn(void* data, int result)
    {
        error_code = result;
        cyg_semaphore_post(&completion_wait);
    }

    int
    blocking_receive(usbs_rx_endpoint* ep, unsigned char* buf, int len)
    {
        error_code = 0;
        usbs_start_rx_buffer(ep, buf, len, &completion_fn, NULL);
        cyg_semaphore_wait(&completion_wait);
        return error_code;
    }

There is also a utility function `usbs_start_rx`. This can be used by code that wants to manipulate data endpoints directly, specifically the `complete_fn`, `complete_data`, `buffer` and `buffer_size` fields. `usbs_start_tx` just invokes a function supplied by the device driver.

Prev | Home | Next
Devtab Entries | Up | Sending Data to the Host