drivers/usb/udc_lib.c

Go to the documentation of this file.

#include <byteorder.h>
#include <debug.h>
#include <usb/function.h>
#include <usb/udc.h>
#include <usb/usb_protocol.h>

static int udc_lib_standard_request(struct udc *udc, struct usb_setup_req *req)
{
        uint16_t        value = le16_to_cpu(req->wValue);
        uint16_t        index = le16_to_cpu(req->wIndex);
        uint16_t        len = le16_to_cpu(req->wLength);
        uint8_t         byte;

        switch (req->bRequest) {
        case USB_REQ_GET_STATUS: {
                le16_t  status = LE16(0);
                int     ret;

                if (len != sizeof(status) || usb_req_is_out(req))
                        return -1;

                switch (usb_req_recipient(req)) {
                case USB_RECIP_DEVICE:
                        /*
                         * Assuming that we are self-powered, although
                         * we really don't know that...
                         */
                        status = LE16(0x0001);
                        break;
                case USB_RECIP_ENDPOINT:
                        ret = udc_ep_is_halted(udc, index & USB_EP_ADDR_MASK);
                        if (ret < 0)
                                return -1;

                        status = cpu_to_le16(ret);
                        break;
                default:
                        break;
                }

                udc_ep0_write_sync(udc, &status, sizeof(status));
                udc_ep0_expect_status(udc);
                break;
        }

        case USB_REQ_CLEAR_FEATURE:
                if (len != 0 || usb_req_is_in(req))
                        return -1;

                if (usb_req_recipient(req) == USB_RECIP_DEVICE
                                && value == USB_DEV_FEATURE_REMOTE_WAKEUP) {
                        /* do nothing */
                } else if (usb_req_recipient(req) == USB_RECIP_ENDPOINT
                                && value == USB_EP_FEATURE_HALT) {
                        if (udc_ep_clear_halt(udc, index & USB_EP_ADDR_MASK))
                                return -1;
                } else {
                        return -1;
                }

                udc_ep0_send_status(udc);
                break;

        case USB_REQ_SET_FEATURE:
                if (len != 0 || usb_req_is_in(req))
                        return -1;
                if (udc_is_high_speed(udc)
                                && usb_req_recipient(req) == USB_RECIP_DEVICE
                                && value == USB_DEV_FEATURE_TEST_MODE) {
                        if (index & 0xff)
                                return -1;

                        /*
                         * Unconfigure the device, terminating all
                         * ongoing requests.
                         */
                        usb_func_set_configuration(udc, 0);

                        if (udc_enter_test_mode(udc, index >> 8))
                                return -1;
                } else if (usb_req_recipient(req) == USB_RECIP_ENDPOINT
                                && value == USB_EP_FEATURE_HALT) {
                        if (udc_ep_set_halt(udc, index & USB_EP_ADDR_MASK))
                                return -1;
                } else {
                        return -1;
                }

                udc_ep0_send_status(udc);
                break;

        case USB_REQ_SET_ADDRESS:
                if (len != 0 || usb_req_is_in(req) || value > 127)
                        return -1;

                /*
                 * The address isn't actually changed until the status
                 * stage is complete. Make sure we don't handle any
                 * SETUP packets until then.
                 */
                udc_set_address(udc, value);
                udc_ep0_send_status(udc);
                break;

        case USB_REQ_GET_DESCRIPTOR:
                if (usb_req_is_out(req))
                        return -1;

                if (usb_func_get_descriptor(udc, value, index, len) < 0)
                        return -1;
                break;

        case USB_REQ_SET_DESCRIPTOR:
                /* Not supported (defined as optional by the USB 2.0 spec) */
                return -1;

        case USB_REQ_GET_CONFIGURATION:
                if (len != sizeof(byte) || usb_req_is_out(req))
                        return -1;

                byte = 0;
                if (udc->config)
                        byte = udc->config->bConfigurationValue;

                udc_ep0_write_sync(udc, &byte, sizeof(byte));
                udc_ep0_expect_status(udc);
                break;

        case USB_REQ_SET_CONFIGURATION:
                if (len != 0 || usb_req_is_in(req) || !udc->address)
                        return -1;

                if (usb_func_set_configuration(udc, value) < 0)
                        return -1;

                udc_ep0_send_status(udc);
                break;

        case USB_REQ_GET_INTERFACE:
                if (len != 1 || usb_req_is_out(req) || !udc->config)
                        return -1;

                if (usb_func_get_interface(udc, index) < 0)
                        return -1;
                break;

        case USB_REQ_SET_INTERFACE:
                if (len != 0 || usb_req_is_in(req) || !udc->config)
                        return -1;

                if (usb_func_set_interface(udc, index, value) < 0)
                        return -1;

                udc_ep0_send_status(udc);
                break;

        default:
                return -1;
        }

        return 0;
}

int udc_lib_process_setup_request(struct udc *udc, struct usb_setup_req *req)
{
        dbg_printf("req %02x: t%02x v%04x i%04x l%04x\n",
                   req->bRequest, req->bmRequestType,
                   le16_to_cpu(req->wValue), le16_to_cpu(req->wIndex),
                   le16_to_cpu(req->wLength));

        if (usb_req_type(req) == USB_REQTYPE_STANDARD)
                return udc_lib_standard_request(udc, req);
        else
                return usb_func_process_setup_request(udc, req);
}

---