drivers/usb/core/dev_mux.c

Go to the documentation of this file.

#include <assert.h>
#include <byteorder.h>
#include <debug.h>
#include <dmapool.h>
#include <interrupt.h>
#include <malloc.h>
#include <status_codes.h>
#include <string.h>
#include <util.h>
#include <usb/dev.h>
#include <usb/dev_mux.h>
#include <usb/request.h>
#include <usb/udc.h>

#include <app/usb.h>




#ifndef USB_STRING_DEV_MANUFACTURER
# define USB_STRING_DEV_MANUFACTURER    0
#endif
#ifndef USB_STRING_DEV_PRODUCT
# define USB_STRING_DEV_PRODUCT         0
#endif
#ifndef USB_STRING_DEV_SERIAL
# define USB_STRING_DEV_SERIAL          0
#endif


static const struct usb_device_descriptor udm_device_desc = {
        .bLength                = sizeof(struct usb_device_descriptor),
        .bDescriptorType        = USB_DT_DEVICE,
        .bcdUSB                 = LE16(0x0200),
        .bDeviceClass           = APP_USB_DEVICE_CLASS,
        .bDeviceSubClass        = APP_USB_DEVICE_SUBCLASS,
        .bDeviceProtocol        = APP_USB_DEVICE_PROTOCOL,
        .bMaxPacketSize0        = APP_UDC_MAXPACKETSIZE0,
        .idVendor               = LE16(APP_USB_DEVICE_VENDOR_ID),
        .idProduct              = LE16(APP_USB_DEVICE_PRODUCT_ID),
        .bcdDevice              = LE16((APP_USB_DEVICE_MAJOR_VERSION << 8)
                                        | APP_USB_DEVICE_MINOR_VERSION),
        .iManufacturer          = USB_STRING_DEV_MANUFACTURER,
        .iProduct               = USB_STRING_DEV_PRODUCT,
        .iSerialNumber          = USB_STRING_DEV_SERIAL,
        .bNumConfigurations     = APP_USB_DEVICE_NR_CONFIGS,
};

#ifdef CONFIG_UDC_HIGH_SPEED
static const struct usb_device_qualifier_descriptor udm_device_qual = {
        .bLength        = sizeof(struct usb_device_qualifier_descriptor),
        .bDescriptorType        = USB_DT_DEVICE_QUALIFIER,
        .bcdUSB                 = LE16(0x0200),
        .bDeviceClass           = APP_USB_DEVICE_CLASS,
        .bDeviceSubClass        = APP_USB_DEVICE_SUBCLASS,
        .bDeviceProtocol        = APP_USB_DEVICE_PROTOCOL,
        .bMaxPacketSize0        = APP_UDC_MAXPACKETSIZE0,
        .bNumConfigurations     = APP_USB_DEVICE_NR_CONFIGS,
};
#endif

static const struct usb_configuration_descriptor udm_config_desc_template = {
        .bLength                = sizeof(struct usb_configuration_descriptor),
        .bDescriptorType        = USB_DT_CONFIGURATION,
        .bmAttributes           = USB_CONFIG_ATTR_MUST_SET
                                        | USB_CONFIG_ATTR_SELF_POWERED,
        .bMaxPower              = USB_CONFIG_MAX_POWER(4),
};

static struct udm_config *udm_config[APP_USB_DEVICE_NR_CONFIGS];
static struct usb_request udm_control_req;
static struct buffer udm_desc_buf;

static struct udm_config *udm_get_config(unsigned int id)
{
        return udm_config[id - 1];
}

static struct udm_config *udm_get_current_config(struct udc *udc)
{
        if (!udc->config)
                return NULL;

        return udm_get_config(udc->config);
}

static unsigned int udm_nr_interfaces(struct udm_config *config)
{
        return config->desc.bNumInterfaces;
}


void udm_config_add_interface(struct udm_config *config,
                struct udm_interface *iface)
{
        unsigned int    id = iface->iface_number;

        assert(id < udm_nr_interfaces(config));
        assert(!config->interface[id]);

        config->interface[id] = iface;

        dbg_info("udm: config %u: new interface %u\n",
                        config->desc.bConfigurationValue, id);
}

struct udm_config *udm_create_config(uint8_t value,
                uint8_t nr_interfaces)
{
        struct udm_config       *config;

        assert(value > 0 && value <= APP_USB_DEVICE_NR_CONFIGS);
        assert(!udm_get_config(value));

        config = zalloc(sizeof(struct udm_config)
                        + nr_interfaces * sizeof(config->interface[0]));
        if (unlikely(!config))
                return NULL;

        memcpy(&config->desc, &udm_config_desc_template, sizeof(config->desc));
        config->desc.bConfigurationValue = value;
        config->desc.bNumInterfaces = nr_interfaces;

        udm_config[value - 1] = config;

        return config;
}

void udm_config_set_max_power(struct udm_config *config,
                unsigned int milliamps)
{
        assert(USB_CONFIG_MAX_POWER(milliamps) < 256);
        config->desc.bMaxPower = USB_CONFIG_MAX_POWER(milliamps);
}

void udm_config_set_self_powered(struct udm_config *config)
{
        irqflags_t      iflags;

        /* Maybe we should add size-aware atomic ops...? */
        iflags = cpu_irq_save();
        config->desc.bmAttributes |= USB_CONFIG_ATTR_SELF_POWERED;
        cpu_irq_restore(iflags);
}

void udm_config_set_bus_powered(struct udm_config *config)
{
        irqflags_t      iflags;

        /* Maybe we should add size-aware atomic ops...? */
        iflags = cpu_irq_save();
        config->desc.bmAttributes &= ~USB_CONFIG_ATTR_SELF_POWERED;
        cpu_irq_restore(iflags);
}


static void udm_ctrl_in_done(struct udc *udc, struct usb_request *req)
{
        dbg_verbose("udm: Control IN request done\n");

        udc_ep0_expect_status(udc);
}

static void udm_config_desc_sent(struct udc *udc, struct usb_request *req)
{
        struct udm_config       *config = req->context;
        unsigned int            i;

        /* Pop the configuration descriptor */
        slist_pop_head_node(&req->buf_list);

        /* Ask all interfaces to remove of their own buffers */
        for (i = 0; i < udm_nr_interfaces(config); i++) {
                struct udm_interface    *iface;

                if (slist_is_empty(&req->buf_list))
                        break;

                iface = config->interface[i];
                iface->free_descriptor(iface, req);
        }

        udm_ctrl_in_done(udc, req);
}

static void udm_string_desc_in_done(struct udc *udc,
                struct usb_request *req)
{
        struct buffer   *buf;

        buf = slist_pop_head(&req->buf_list, struct buffer, node);
        buffer_dma_free(buf, USB_MAX_DESC_LEN);

        udm_ctrl_in_done(udc, req);
}


int udm_submit_utf16le_string_desc(struct udc *udc, struct usb_request *req,
                const le16_t *str, uint16_t max_len)
{
        struct usb_string_descriptor    *desc;
        struct buffer                   *buf;
        const le16_t                    *src;
        le16_t                          *dst;
        uint16_t                        len;

        if (max_len < offsetof(struct usb_string_descriptor, bString))
                return ERR_INVALID_ARG;

        buf = buffer_dma_alloc(USB_MAX_DESC_LEN);
        if (!buf)
                return ERR_NO_MEMORY;

        desc = buf->addr.ptr;
        desc->bDescriptorType = USB_DT_STRING;

        src = str;
        dst = desc->bString;
        for (len = offsetof(struct usb_string_descriptor, bString);
                        len < max_len; len += 2) {
                le16_t  c = *src++;

                if (c == LE16(0))
                        break;
                *dst++ = c;
        }

        desc->bLength = len;
        buffer_resize(buf, len);
        usb_req_add_buffer(req, buf);
        req->req_done = udm_string_desc_in_done;

        return len;
}

int udm_submit_ascii_string_desc(struct udc *udc, struct usb_request *req,
                const char *str, uint16_t max_len)
{
        struct usb_string_descriptor    *desc;
        struct buffer                   *buf;
        const char                      *src;
        le16_t                          *dst;
        uint16_t                        len;

        if (max_len < offsetof(struct usb_string_descriptor, bString))
                return ERR_INVALID_ARG;

        buf = buffer_dma_alloc(USB_MAX_DESC_LEN);
        if (!buf)
                return ERR_NO_MEMORY;

        desc = buf->addr.ptr;
        desc->bDescriptorType = USB_DT_STRING;

        src = str;
        dst = desc->bString;
        for (len = offsetof(struct usb_string_descriptor, bString);
                        len < max_len; len += 2) {
                char    c = *src++;

                if (c == '\0')
                        break;
                *dst++ = cpu_to_le16(c);
        }

        desc->bLength = len;
        buffer_resize(buf, len);
        usb_req_add_buffer(req, buf);
        req->req_done = udm_string_desc_in_done;

        return len;
}

#ifndef HAVE_APP_USB_GET_STRING_DESCRIPTOR
static int app_usb_get_string_descriptor(struct udc *udc,
                struct usb_request *req, uint8_t index,
                uint16_t langid, uint16_t len)
{
        /* String descriptors need application support */
        return -1;
}
#endif


static int udm_prep_config_desc(struct udm_config *config,
                struct usb_request *req,
                enum usb_device_speed speed, size_t max_len)
{
        struct udm_interface            *iface;
        struct buffer                   *buffer;
        size_t                          buf_len;
        size_t                          total_len;
        size_t                          len;
        unsigned int                    i;

        total_len = sizeof(config->desc);
        len = min_u(max_len, total_len);

        buffer = &udm_desc_buf;
        buffer_init_tx(buffer, &config->desc, len);

        req->req_done = udm_config_desc_sent;
        req->context = config;
        usb_req_add_buffer(req, buffer);

        for (i = 0; i < udm_nr_interfaces(config); i++) {
                size_t  remaining_len;

                remaining_len = max_len - len;
                iface = config->interface[i];
                buf_len = iface->get_iface_descriptor(iface, req, speed,
                                remaining_len);
                total_len += buf_len;
                len += min_u(buf_len, remaining_len);
        }

        config->desc.wTotalLength = cpu_to_le16(total_len);

        return len;
}

static int udm_enable_config(struct udc *udc, struct udm_config *config)
{
        unsigned int            nr_interfaces;
        unsigned int            i;

        dbg_verbose("udm: enabling configuration %u...\n",
                        config->desc.bConfigurationValue);

        nr_interfaces = udm_nr_interfaces(config);
        for (i = 0; i < nr_interfaces; i++) {
                struct udm_interface    *iface;

                iface = config->interface[i];
                dbg_verbose("  - enabling interface %u...\n", i);
                if (iface->enable(udc, iface, 0))
                        goto fail;
        }

        return 0;

fail:
        dbg_error("udm: failed to enable configuration %u, interface %u\n",
                        config->desc.bConfigurationValue, i);
        while (i-- > 0) {
                struct udm_interface    *iface;

                iface = config->interface[i];
                iface->disable(udc, iface);
        }

        return -1;
}

static void udm_disable_config(struct udc *udc, struct udm_config *config)
{
        unsigned int            nr_interfaces;
        unsigned int            i;

        if (!config)
                return;

        dbg_verbose("udm: disabling configuration %u\n",
                        config->desc.bConfigurationValue);

        nr_interfaces = udm_nr_interfaces(config);
        for (i = 0; i < nr_interfaces; i++) {
                struct udm_interface    *iface;

                iface = config->interface[i];
                dbg_verbose("  - disabling interface %u...\n", i);
                iface->disable(udc, iface);
        }
}

#if 0
static int udm_prep_string_desc(struct udc *udc,
                struct usb_request *req, uint8_t desc_index,
                uint16_t langid, uint16_t len)
{
        struct usb_string_descriptor    *desc;
        struct buffer                   *buf;
        const char                      *str;
        phys_addr_t                     desc_phys;
        int                             str_len;

        if (desc_index >= USB_NR_STRINGS)
                return -1;
        if (desc_index != USB_STRING_LANGID && langid != USB_DEV_LANGID)
                return -1;

        str = usb_dev_string_table[desc_index];
        if (!str)
                return -1;

        desc = dma_alloc(&desc_phys, USB_MAX_DESC_SIZE);
        if (!desc)
                return -1;

        desc->bDescriptorType = USB_DT_STRING;
        if (desc_index == USB_STRING_LANGID) {
                desc->bString[0] = LE16(USB_DEV_LANGID);
                desc->bLength = 4;
        } else {
                str_len = ascii_to_usb_str(str, desc->bString,
                                USB_MAX_DESC_SIZE - 2);
                desc->bLength = str_len + 2;
        }

        buf = &udm_desc_buf;
        buffer_init_tx_mapped(buf, desc, desc_phys, min_u(desc->bLength, len));
        usb_req_add_buffer(req, buf);

        req->req_done = udm_string_desc_in_done;

        return buf->len;
}
#endif


status_t usb_dev_get_descriptor(struct udc *udc, uint16_t value,
                uint16_t index, uint16_t len)
{
        struct udm_config       *config;
        struct usb_request      *req;
        unsigned int            desc_index;
        unsigned int            desc_type;
        int                     buf_len = -1;

        dbg_verbose("udm: get descriptor v%04x i%04x l%04x\n",
                        value, index, len);

        req = &udm_control_req;
        usb_req_init(req);
        req->req_done = udm_ctrl_in_done;

        desc_type = value >> 8;
        desc_index = value & 0xff;

        switch (desc_type) {
        case USB_DT_DEVICE:
                buf_len = min_u(len, sizeof(udm_device_desc));
                buffer_init_tx(&udm_desc_buf, &udm_device_desc,
                                buf_len);
                usb_req_add_buffer(req, &udm_desc_buf);
                break;

        case USB_DT_CONFIGURATION:
                if (desc_index >= APP_USB_DEVICE_NR_CONFIGS)
                        return -1;

                config = udm_config[desc_index];
                config->desc.bDescriptorType = desc_type;
                buf_len = udm_prep_config_desc(config, req,
                                udc->speed, len);
                break;

#ifdef CONFIG_UDC_HIGH_SPEED
        case USB_DT_DEVICE_QUALIFIER:
                buf_len = min_u(len, sizeof(udm_device_qual));
                buffer_init_tx(&udm_desc_buf, &udm_device_qual,
                                buf_len);
                usb_req_add_buffer(req, &udm_desc_buf);
                break;

        case USB_DT_OTHER_SPEED_CONFIGURATION:
                if (desc_index >= APP_USB_DEVICE_NR_CONFIGS)
                        return -1;

                config = udm_config[desc_index];
                config->desc.bDescriptorType = desc_type;

                if (udc->speed == USB_SPEED_HIGH)
                        buf_len = udm_prep_config_desc(config, req,
                                        USB_SPEED_FULL, len);
                else
                        buf_len = udm_prep_config_desc(config, req,
                                        USB_SPEED_HIGH, len);
                break;
#endif

        case USB_DT_STRING:
                buf_len = app_usb_get_string_descriptor(udc, req,
                                desc_index, index, len);
                break;
        }

        if (buf_len < 0)
                return buf_len;

        if (buf_len < len)
                set_bit(USB_REQ_SHORT_PKT, &req->flags);

        udc_ep0_submit_in_req(udc, req);

        return STATUS_OK;
}

status_t usb_dev_set_configuration(struct udc *udc, uint16_t config_id)
{
        struct udm_config       *old;
        struct udm_config       *new;

        dbg_verbose("udm: set configuration %u\n", config_id);

        if (config_id > APP_USB_DEVICE_NR_CONFIGS)
                return -1;

        /* Disable the old configuration, if any */
        old = udm_get_current_config(udc);
        udc->config = 0;
        if (old)
                udm_disable_config(udc, old);

        if (config_id == 0)
                return STATUS_OK;

        new = udm_get_config(config_id);
        udc->config = config_id;
        if (udm_enable_config(udc, new)) {
                udc->config = 0;
                return -1;
        }

        return STATUS_OK;
}

status_t usb_dev_get_interface(struct udc *udc, uint16_t index)
{
        struct udm_config               *config;
        struct udm_interface            *iface;

        dbg_verbose("udm: get interface %u\n", index);

        config = udm_get_current_config(udc);
        if (!config || index >= udm_nr_interfaces(config))
                return -1;

        iface = config->interface[index];
        build_assert(sizeof(iface->cur_setting) == 1);

        udc_ep0_write_sync(udc, &iface->cur_setting, 1);
        udc_ep0_expect_status(udc);

        return 0;
}

status_t usb_dev_set_interface(struct udc *udc, uint16_t index,
                uint16_t altsetting)
{
        struct udm_config               *config;
        struct udm_interface            *iface;
        int                             ret;

        dbg_verbose("udm: set interface %u altsetting %u\n",
                        index, altsetting);

        config = udm_get_current_config(udc);
        if (!config || index >= udm_nr_interfaces(config))
                return -1;

        iface = config->interface[index];
        ret = iface->enable(udc, iface, altsetting);
        if (likely(!ret))
                iface->cur_setting = altsetting;

        return ret;
}

void usb_dev_reset(struct udc *udc)
{
        dbg_verbose("udm: reset, speed=%u\n", udc->speed);

        if (udc->config)
                usb_dev_set_configuration(udc, 0);
}

status_t usb_dev_process_setup_request(struct udc *udc,
                struct usb_setup_req *req)
{
        struct udm_config               *config;
        struct udm_interface            *iface;
        uint16_t                        index = le16_to_cpu(req->wIndex);

        if (usb_setup_recipient(req) != USB_RECIP_INTERFACE) {
                dbg_warning("udm: bad request (bmRequestType: %u)\n",
                                req->bmRequestType);
                return -1;
        }

        config = udm_get_current_config(udc);
        if (!config || index >= udm_nr_interfaces(config)) {
                dbg_warning("udm: bad interface %u\n", index);
                return -1;
        }

        iface = config->interface[index];
        if (!iface->setup)
                return -1;

        return iface->setup(udc, iface, req);
}

---