eCos USB Slave Support
Prev |  | Next

# USB Enumeration Data

## Name

Enumeration Data -- The USB enumeration data structures

## Synopsis

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

    typedef struct usb_device_descriptor {
        …
    } usb_device_descriptor __attribute__((packed));

    typedef struct usb_configuration_descriptor {
        …
    } usb_configuration_descriptor __attribute__((packed));

    typedef struct usb_interface_descriptor {
        …
    } usb_interface_descriptor __attribute__((packed));

    typedef struct usb_endpoint_descriptor {
        …
    } usb_endpoint_descriptor;

    typedef struct usbs_enumeration_data {
        usb_device_descriptor               device;
        int                                 total_number_interfaces;
        int                                 total_number_endpoints;
        int                                 total_number_strings;
        const usb_configuration_descriptor* configurations;
        const usb_interface_descriptor*     interfaces;
        const usb_endpoint_descriptor*      endpoints;
        const unsigned char**               strings;
    } usbs_enumeration_data;

## USB Enumeration Data

When a USB host detects that a peripheral has been plugged in or powered up, one of the first steps is to ask the peripheral to describe itself by supplying enumeration data. Some of this data depends on the class of peripheral. Other fields are vendor-specific. There is also a dependency on the hardware, specifically which endpoints are available should be used. In general it is not possible for generic code to provide this information, so it is the responsibility of application code to provide a suitable usbs_enumeration_data data structure and install it in the endpoint 0 data structure during initialization. This must happen before the USB device is enabled by a call to `usbs_start` , for example:

    const usbs_enumeration_data usb_enum_data = {
        …
    };

    int
    main(int argc, char** argv)
    {
        usbs_sa11x0_ep0.enumeration_data = &usb_enum_data;
        …
        usbs_start(&usbs_sa11x0_ep0);
        …
    }

For most applications the enumeration data will be static, although the usbs_enumeration_data structure can be filled in at run-time if necessary. Full details of the enumeration data can be found in the Universal Serial Bus specification obtainable from the USB Implementers Forum web site , although the meaning of most fields is fairly obvious. The various data structures and utility macros are defined in the header files `cyg/io/usb/usb.h` and `cyg/io/usb/usbs.h` . Note that the example code below makes use of the gcc labelled element extension.

### usb_device_descriptor

The main information about a USB peripheral comes from a single usb_device_descriptor structure, which is embedded in the usbs_enumeration_data structure. A typical example might look like this:

    const usbs_enumeration_data usb_enum_data = {
        {
            length:                 USB_DEVICE_DESCRIPTOR_LENGTH,
            type:                   USB_DEVICE_DESCRIPTOR_TYPE,
            usb_spec_lo:            USB_DEVICE_DESCRIPTOR_USB11_LO,
            usb_spec_hi:            USB_DEVICE_DESCRIPTOR_USB11_HI,
            device_class:           USB_DEVICE_DESCRIPTOR_CLASS_VENDOR,
            device_subclass:        USB_DEVICE_DESCRIPTOR_SUBCLASS_VENDOR,
            device_protocol:        USB_DEVICE_DESCRIPTOR_PROTOCOL_VENDOR,
            max_packet_size:        8,
            vendor_lo:              0x42,
            vendor_hi:              0x42,
            product_lo:             0x42,
            product_hi:             0x42,
            device_lo:              0x00,
            device_hi:              0x01,
            manufacturer_str:       1,
            product_str:            2,
            serial_number_str:      0,
            number_configurations:  1
        },
        …
    };

The length and type fields are specified by the USB standard. The `usb_spec_lo` and `usb_spec_hi` fields identify the particular revision of the standard that the peripheral implements, for example revision 1.1.

The device class, subclass, and protocol fields are used by generic host-side USB software to determine which host-side device driver should be loaded to interact with the peripheral. A number of standard classes are defined, for example mass-storage devices and human-interface devices. If a peripheral implements one of the standard classes then a standard existing host-side device driver may exist, eliminating the need to write a custom driver. The value `0xFF` (`VENDOR` ) is reserved for peripherals that implement a vendor-specific protocol rather than a standard one. Such peripherals will require a custom host-side device driver. The value `0x00` (`INTERFACE` ) is reserved and indicates that the protocol used by the peripheral is defined at the interface level rather than for the peripheral as a whole.

The `max_package_size` field specifies the maximum length of a control message. There is a lower bound of eight bytes, and typical hardware will not support anything larger because control messages are usually small and not performance-critical.

The `vendor_lo` and `vendor_hi` fields specify a vendor id, which must be obtained from the USB Implementor's Forum. The numbers used in the code fragment above are examples only and must not be used in real USB peripherals. The product identifier is determined by the vendor, and different USB peripherals should use different identifiers. The device identifier field should indicate a release number in binary-coded decimal.

The above fields are all numerical in nature. A USB peripheral can also provide a number of strings as described below , for example the name of the vendor can be provided. The various `_str` fields act as indices into an array of strings, with index 0 indicating that no string is available.

A typical USB peripheral involves just a single configuration. However more complicated peripherals can support multiple configurations. Only one configuration will be active at any one time, and the host will switch between them as appropriate. If a peripheral does involve multiple configurations then typically it will be the responsibility of application code to handle the standard set-configuration control message.

### usb_configuration_descriptor

A USB peripheral involves at least one and possible several different configurations. The usbs_enumeration_data structure requires a pointer to an array, possibly of length 1, of usb_configuration_descriptor structures. Usually a single structure suffices:

    const usb_configuration_descriptor usb_configuration = {
        length:             USB_CONFIGURATION_DESCRIPTOR_LENGTH,
        type:               USB_CONFIGURATION_DESCRIPTOR_TYPE,
        total_length_lo:    USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH_LO(1, 2),
        total_length_hi:    USB_CONFIGURATION_DESCRIPTOR_TOTAL_LENGTH_HI(1, 2),
        number_interfaces:  1,
        configuration_id:   1,
        configuration_str:  0,
        attributes:         USB_CONFIGURATION_DESCRIPTOR_ATTR_REQUIRED |
                            USB_CONFIGURATION_DESCRIPTOR_ATTR_SELF_POWERED,
        max_power:          50
    };

    const usbs_enumeration_data usb_enum_data = {
        …
        configurations:             &usb_configuration,
        …
    };

The values for the `length` and `type` fields are determined by the standard. The `total_length` field depends on the number of interfaces and endpoints used by this configuration, and convenience macros are provided to calculate this: the first argument to the macros specify the number of interfaces, the second the number of endpoints. The `number_interfaces` field is self-explanatory. If the peripheral involves multiple configurations then each one must have a unique id, and this will be used in the set-configuration control message. The id `0` is reserved, and a set-configuration control message that uses this id indicates that the peripheral should be inactive. Configurations can have a string description if required. The `attributes` field must have the `REQUIRED` bit set; the `SELF_POWERED` bit informs the host that the peripheral has its own power supply and will not draw any power over the bus, leaving more bus power available to other peripherals; the `REMOTE_WAKEUP` bit is used if the peripheral can interrupt the host when the latter is in power-saving mode. For peripherals that are not self-powered, the `max_power` field specifies the power requirements in units of 2mA.

### usb_interface_descriptor

A USB configuration involves one or more interfaces, typically corresponding to different streams of data. For example, one interface might involve video data while another interface is for audio. Multiple interfaces in a single configuration will be active at the same time.

    const usb_interface_descriptor usb_interface = {
        length:             USB_INTERFACE_DESCRIPTOR_LENGTH,
        type:               USB_INTERFACE_DESCRIPTOR_TYPE,
        interface_id:       0,
        alternate_setting:  0,
        number_endpoints:   2,
        interface_class:    USB_INTERFACE_DESCRIPTOR_CLASS_VENDOR,
        interface_subclass: USB_INTERFACE_DESCRIPTOR_SUBCLASS_VENDOR,
        interface_protocol: USB_INTERFACE_DESCRIPTOR_PROTOCOL_VENDOR,
        interface_str:      0
    };

    const usbs_enumeration_data usb_enum_data = {
        …
        total_number_interfaces:    1,
        interfaces:                 &usb_interface,
        …
    };

Again, the `length` and `type` fields are specified by the standard. Each interface within a configuration requires its own id. However, a given interface may have several alternate settings, in other words entries in the interfaces array with the same id but different `alternate_setting` fields. For example, there might be one setting which requires a bandwidth of 100K/s and another setting that only needs 50K/s. The host can use the standard set-interface control message to choose the most appropriate setting. The handling of this request is the responsibility of higher-level code, so the application may have to install its own handler.

The number of endpoints used by an interface is specified in the `number_endpoints` field. Exact details of which endpoints are used is held in a separate array of endpoint descriptors. The class, subclass and protocol fields are used by host-side code to determine which host-side device driver should handle this specific interface. Usually this is determined on a per-peripheral basis in the usb_device_descriptor structure, but that can defer the details to individual interfaces. A per-interface string is allowed as well.

For USB peripherals involving multiple configurations, the array of usb_interface_descriptor structures should first contain all the interfaces for the first configuration, then all the interfaces for the second configuration, and so on.

### usb_endpoint_descriptor

The host also needs information about which endpoint should be used for what. This involves an array of endpoint descriptors:

    const usb_endpoint_descriptor usb_endpoints[] = {
        {
            length:         USB_ENDPOINT_DESCRIPTOR_LENGTH,
            type:           USB_ENDPOINT_DESCRIPTOR_TYPE,
            endpoint:       USB_ENDPOINT_DESCRIPTOR_ENDPOINT_OUT | 1,
            attributes:     USB_ENDPOINT_DESCRIPTOR_ATTR_BULK,
            max_packet_lo:  64,
            max_packet_hi:  0,
            interval:       0
        },
        {
            length:         USB_ENDPOINT_DESCRIPTOR_LENGTH,
            type:           USB_ENDPOINT_DESCRIPTOR_TYPE,
            endpoint:       USB_ENDPOINT_DESCRIPTOR_ENDPOINT_IN | 2,
            attributes:     USB_ENDPOINT_DESCRIPTOR_ATTR_BULK,
            max_packet_lo:  64,
            max_packet_hi:  0,
            interval:       0
        }
    };

    const usbs_enumeration_data usb_enum_data = {
        …
        total_number_endpoints:     2,
        endpoints:                  usb_endpoints,
        …
    };

As usual the values for the `length` and `type` fields are specified by the standard. The `endpoint` field gives both the endpoint number and the direction, so in the above example endpoint 1 is used for OUT (host to peripheral) transfers and endpoint 2 is used for IN (peripheral to host) transfers. The `attributes` field indicates the USB protocol that should be used on this endpoint: `CONTROL` , `ISOCHRONOUS` , `BULK` or `INTERRUPT` . The `max_packet` field specifies the maximum size of a single USB packet. For bulk transfers this will typically be 64 bytes. For isochronous transfers this can be up to 1023 bytes. For interrupt transfers it can be up to 64 bytes, although usually a smaller value will be used. The `interval` field is ignored for control and bulk transfers. For isochronous transfers it should be set to 1. For interrupt transfers it can be a value between 1 and 255, and indicates the number of milliseconds between successive polling operations.

For USB peripherals involving multiple configurations or interfaces the array of endpoint descriptors should be organized sequentially: first the endpoints corresponding to the first interface of the first configuration, then the second interface in that configuration, and so on; then all the endpoints for all the interfaces in the second configuration; etc.

### Strings

The enumeration data can contain a number of strings with additional information. Unicode encoding is used for the strings, and it is possible for a peripheral to supply a given string in multiple languages using the appropriate characters. The first two bytes of each string give a length and type field. The first string is special; after the two bytes header it consists of an array of 2-byte language id codes, indicating the supported languages. The language code 0x0409 corresponds to English (United States).

    const unsigned char* usb_strings[] = {
        "\x04\x03\x09\x04",
        "\x10\x03R\0e\0d\0 \0H\0a\0t\0"
    };

    const usbs_enumeration_data usb_enum_data = {
        …
        total_number_strings:       2,
        strings:                    usb_strings,
        …
    };

The default handler for standard control messages assumes that the peripheral only uses a single language. If this is not the case then higher-level code will have to handle the standard get-descriptor control messages when a string descriptor is requested.

### usbs_enumeration_data

The usbs_enumeration_data data structure collects together all the various descriptors that make up the enumeration data. It is the responsibility of application code to supply a suitable data structure and install it in the control endpoints's `enumeration_data` field before the USB device is started.

Prev | Home | Next
Introduction |  | Starting up a USB Device