Subversion Repositories freemyipod

//

#include "global.h"

//

#include "usb.h"

//    Copyright 2010 TheSeven

#include "util.h"

//

//

void usb_start_rx(const struct usb_instance* data, union usb_endpoint_number ep, void* buf, int size)

//    This file is part of emCORE.

{

//

    data->driver->start_rx(data, ep, buf, size);

//    emCORE 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 of the

void usb_start_tx(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size)

//    License, or (at your option) any later version.

{

//

    data->driver->start_tx(data, ep, buf, size);

//    emCORE 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.

void usb_set_stall(const struct usb_instance* data, union usb_endpoint_number ep, int stall)

//    See the GNU General Public License for more details.

{

//

    data->driver->set_stall(data, ep, stall);

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

}

//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.

//

void usb_ep0_start_rx(const struct usb_instance* data, int non_setup, bool (*callback)(const struct usb_instance* data, int bytesleft))

//

{

    data->state->ep0_rx_callback = callback;

    data->driver->ep0_start_rx(data, non_setup);

#include "global.h"

}

#include "panic.h"

#include "usb.h"

bool usb_ep0_rx_callback(const struct usb_instance* data, int bytesleft)

#include "usb_ch9.h"

{

#include "usbdrv.h"

    usb_ep0_start_rx(data, 0, NULL);

#include "thread.h"

    return true;

#include "console.h"

}

#include "util.h"

#include "contextswitch.h"

void usb_ep0_start_tx(const struct usb_instance* data, const void* buf, int len, bool last, bool (*callback)(const struct usb_instance* data, int bytesleft))

#include "power.h"

{

#include "mmu.h"

    // Expect zero-length ACK if we are about to actually send data, otherwise expect SETUP.

#include "shutdown.h"

    if (last) usb_ep0_start_rx(data, !!len, usb_ep0_rx_callback);

#include "execimage.h"

#include "dbgconsole.h"

    if (((uint32_t)buf) & (CACHEALIGN_SIZE - 1))

#ifdef HAVE_I2C

    {

#include "i2c.h"

        memcpy(data->buffer->raw, buf, len);

#endif

        buf = data->buffer->raw;

#ifdef HAVE_BOOTFLASH

    }

#include "bootflash.h"

#endif

    data->state->ep0_tx_callback = callback;

#ifdef HAVE_HWKEYAES

    data->driver->ep0_start_tx(data, buf, len);

#include "hwkeyaes.h"

}

#endif

#ifdef HAVE_HMACSHA1

bool usb_ep0_tx_callback(const struct usb_instance* data, int bytesleft)

#include "hmacsha1.h"

{

#endif

    if (bytesleft || !data->state->ep0_tx_len) return false;

#ifdef USB_HAVE_TARGET_SPECIFIC_REQUESTS

    int len = MIN(64, data->state->ep0_tx_len);

#include "usbtarget.h"

    data->state->ep0_tx_ptr += 64;

#endif

    data->state->ep0_tx_len -= len;

#ifdef HAVE_STORAGE

    usb_ep0_start_tx(data, data->state->ep0_tx_ptr, len, !data->state->ep0_tx_len, usb_ep0_tx_callback);

#include "storage.h"

    return true;

#include "disk.h"

}

#include "file.h"

#include "dir.h"

void usb_unconfigure_ep(const struct usb_instance* data, union usb_endpoint_number ep)

#include "libc/include/errno.h"

{

#endif

    data->driver->unconfigure_ep(data, ep);

}

static uint8_t ctrlresp[2] CACHEALIGN_ATTR;

void usb_configure_ep(const struct usb_instance* data, union usb_endpoint_number ep, enum usb_endpoint_type type, int maxpacket)

static uint32_t dbgrecvbuf[0x80] CACHEALIGN_ATTR;

{

static uint32_t dbgsendbuf[0x80] CACHEALIGN_ATTR;

    // Reset the endpoint, just in case someone left it in a dirty state.

static uint32_t dbgasyncsendbuf[0x80] CACHEALIGN_ATTR;

    usb_unconfigure_ep(data, ep);

static char dbgendpoints[4] IBSS_ATTR;

    // Write the new configuration for the endpoint.

enum dbgaction_t

    // This resets the data toggle to DATA0, as required by the USB specification.

{

    data->driver->configure_ep(data, ep, type, maxpacket);

    DBGACTION_IDLE = 0,

}

    DBGACTION_I2CSEND,

    DBGACTION_I2CRECV,

int usb_get_max_transfer_size(const struct usb_instance* data, union usb_endpoint_number ep)

    DBGACTION_RESET,

{

    DBGACTION_POWEROFF,

    return data->driver->get_max_transfer_size(data, ep);

    DBGACTION_CWRITE,

}

    DBGACTION_CREAD,

    DBGACTION_CFLUSH,

static void usb_unconfigure(const struct usb_instance* data)

    DBGACTION_EXECIMAGE,

{

    DBGACTION_EXECFIRMWARE,

    // Notify a configuration and its active interface altsettings that it was just kicked out.

    DBGACTION_READBOOTFLASH,

    int configid = data->state->current_configuration;

    DBGACTION_WRITEBOOTFLASH,

    if (!configid) return;

    DBGACTION_HWKEYAES,

    const struct usb_configuration* configuration = data->configurations[configid - 1];

    DBGACTION_HMACSHA1,

    int i;

    DBGACTION_TARGETSPECIFIC,

    for (i = 0; i < configuration->interface_count; i++)

    DBGACTION_STORAGE,

    {

    DBGACTION_MALLOC,

        const struct usb_interface* interface = configuration->interfaces[i];

    DBGACTION_MEMALIGN,

        const struct usb_altsetting* altsetting = interface->altsettings[data->state->interface_altsetting[i]];

    DBGACTION_REALLOC,

        if (altsetting->unset_altsetting)

    DBGACTION_REOWNALLOC,

            altsetting->unset_altsetting(data, i, data->state->interface_altsetting[i]);

    DBGACTION_FREE,

    }

    DBGACTION_FREEMONITOR,

    if (configuration->unset_configuration)

    DBGACTION_RTCREAD,

        configuration->unset_configuration(data, configid);

    DBGACTION_RTCWRITE,

    data->state->current_configuration = 0;

};

}

static struct scheduler_thread dbgthread_handle IBSS_ATTR;

static const struct usb_endpoint* usb_find_endpoint(const struct usb_instance* data,

static uint32_t dbgstack[0x200] STACK_ATTR;

                                                    union usb_endpoint_number ep, int* ifidx, int* epidx)

struct wakeup dbgwakeup IBSS_ATTR;

{

static enum dbgaction_t dbgaction IBSS_ATTR;

    // Figure out who's currently owning a (hardware) endpoint.

static int dbgi2cbus;

    // Returns a pointer to the usb_endpoint struct, and sets *epidx to its index within its altsetting.

static int dbgi2cslave;

    // *ifidx will be set to the interface number within the current configuration that the altsetting belongs to.

static int dbgactionaddr;

    // If nobody currently owns the specified endpoint, return NULL (*epidx and *ifidx will contain garbage).

static int dbgactionoffset;

    int configid = data->state->current_configuration;

static int dbgactionlength;

    if (!configid) return NULL;

static int dbgactionconsoles;

    const struct usb_configuration* configuration = data->configurations[configid - 1];

static int dbgactiontype;

    for (*ifidx = 0; *ifidx < configuration->interface_count; (*ifidx)++)

static char dbgconsendbuf[4096];

    {

static char dbgconrecvbuf[1024];

        const struct usb_interface* interface = configuration->interfaces[*ifidx];

static int dbgconsendreadidx IBSS_ATTR;

        const struct usb_altsetting* altsetting = interface->altsettings[data->state->interface_altsetting[*ifidx]];

static int dbgconsendwriteidx IBSS_ATTR;

        for (*epidx = 0; *epidx < altsetting->endpoint_count; (*epidx)++)

static int dbgconrecvreadidx IBSS_ATTR;

        {

static int dbgconrecvwriteidx IBSS_ATTR;

            const struct usb_endpoint* endpoint = altsetting->endpoints[*epidx];

static struct wakeup dbgconsendwakeup IBSS_ATTR;

            if (endpoint->number.byte == ep.byte) return endpoint;

static struct wakeup dbgconrecvwakeup IBSS_ATTR;

        }

static bool dbgconsoleattached IBSS_ATTR;

    }

    return NULL;

static const char dbgconoverflowstr[] = "\n\n[overflowed]\n\n";

}

extern int _poolstart;   // These aren't ints at all, but gcc complains about void types being

static void usb_handle_ep0_setup(const struct usb_instance* data, union usb_ep0_buffer* buffer)

extern int _poolend;     // used here, and we only need the address, so just make it happy...

{

    // size < -2: do nothing at all (dangerous, you need to take care of priming EP0 yourself!)

    // size == -2: send STALL

static struct usb_device_descriptor device_descriptor CACHEALIGN_ATTR =

    // size == -1: try to run default handler, or send STALL if none exists

{

    // size == 0: send ACK

    .bLength            = sizeof(struct usb_device_descriptor),

    // size > 0: send <size> bytes at <addr>, then expect ACK

    .bDescriptorType    = USB_DT_DEVICE,

    const void* addr = data->buffer;

    .bcdUSB             = 0x0200,

    int size = -1;

    .bDeviceClass       = USB_CLASS_VENDOR_SPEC,

    switch (buffer->setup.bmRequestType.recipient)

    .bDeviceSubClass    = 0xff,

    {

    .bDeviceProtocol    = 0xff,

    case USB_SETUP_BMREQUESTTYPE_RECIPIENT_DEVICE:

    .bMaxPacketSize0    = 64,

        if (data->ctrl_request) size = data->ctrl_request(data, buffer, &addr);

    .idVendor           = 0xffff,

        if (size != -1) break;

    .idProduct          = 0xe000,

        switch (buffer->setup.bmRequestType.type)

    .bcdDevice          = 0x0001,

        {

    .iManufacturer      = 1,

        case USB_SETUP_BMREQUESTTYPE_TYPE_STANDARD:

    .iProduct           = 2,

            switch (buffer->setup.bRequest.req)

    .iSerialNumber      = 0,

            {

    .bNumConfigurations = 1

            case USB_SETUP_BREQUEST_GET_STATUS:

};

                if (buffer->setup.wLength != 2 || buffer->setup.wIndex

                 || !data->state->current_address || buffer->setup.wValue) break;

static struct usb_config_bundle

                data->buffer->raw[0] = 0;

{

                data->buffer->raw[1] = 1;

    struct usb_config_descriptor config_descriptor;

                size = 2;

    struct usb_interface_descriptor interface_descriptor;

                break;

    struct usb_endpoint_descriptor endpoint1_descriptor;

            case USB_SETUP_BREQUEST_SET_ADDRESS:

    struct usb_endpoint_descriptor endpoint2_descriptor;

                if (buffer->setup.wLength || buffer->setup.wIndex || buffer->setup.wValue > 127) break;

    struct usb_endpoint_descriptor endpoint3_descriptor;

                data->state->current_address = buffer->setup.wValue;

    struct usb_endpoint_descriptor endpoint4_descriptor;

                // We can already set the address here, the driver has to take care to send the ACK with the old address.

} __attribute__((packed)) config_bundle CACHEALIGN_ATTR =

                data->driver->set_address(data, data->state->current_address);

{

                size = 0;

    .config_descriptor =

                break;

    {

            case USB_SETUP_BREQUEST_GET_DESCRIPTOR:

        .bLength             = sizeof(struct usb_config_descriptor),

                if (!buffer->setup.wLength) break;

        .bDescriptorType     = USB_DT_CONFIG,

                switch (buffer->setup.wValue >> 8)

        .wTotalLength        = sizeof(struct usb_config_descriptor)

                {

                             + sizeof(struct usb_interface_descriptor)

                case USB_DESCRIPTOR_TYPE_DEVICE:

                             + sizeof(struct usb_endpoint_descriptor) * 4,

                    if ((buffer->setup.wValue & 0xff) || buffer->setup.wIndex) break;

        .bNumInterfaces      = 1,

                    addr = data->devicedescriptor;

        .bConfigurationValue = 1,

                    size = data->devicedescriptor->bLength;

        .iConfiguration      = 0,

                    break;

        .bmAttributes        = USB_CONFIG_ATT_ONE,

                case USB_DESCRIPTOR_TYPE_CONFIGURATION:

        .bMaxPower           = 250

                    if (buffer->setup.wIndex

    },

                     || (buffer->setup.wValue & 0xff) >= data->configuration_count) break;

    .interface_descriptor =

                    addr = data->configurations[buffer->setup.wValue & 0xff]->descriptor;

    {

                    size = data->configurations[buffer->setup.wValue & 0xff]->descriptor->wTotalLength;

        .bLength             = sizeof(struct usb_interface_descriptor),

                    break;

        .bDescriptorType     = USB_DT_INTERFACE,

                case USB_DESCRIPTOR_TYPE_STRING:

        .bInterfaceNumber    = 0,

                    if ((buffer->setup.wValue & 0xff) > data->stringdescriptor_count) break;

        .bAlternateSetting   = 0,

                    addr = data->stringdescriptors[buffer->setup.wValue & 0xff];

        .bNumEndpoints       = 4,

                    size = data->stringdescriptors[buffer->setup.wValue & 0xff]->bLength;

        .bInterfaceClass     = USB_CLASS_VENDOR_SPEC,

                    break;

        .bInterfaceSubClass  = 0xff,

                }

        .bInterfaceProtocol  = 0xff,

                if (size > buffer->setup.wLength) size = buffer->setup.wLength;

        .iInterface          = 0

                break;

    },

            case USB_SETUP_BREQUEST_GET_CONFIGURATION:

    .endpoint1_descriptor =

                if (buffer->setup.wLength != 1 || buffer->setup.wIndex

    {

                 || !data->state->current_address || buffer->setup.wValue) break;

        .bLength             = sizeof(struct usb_endpoint_descriptor),

                data->buffer->raw[0] = data->state->current_configuration;

        .bDescriptorType     = USB_DT_ENDPOINT,

                size = 1;

        .bEndpointAddress    = 0,

                break;

        .bmAttributes        = USB_ENDPOINT_XFER_BULK,

            case USB_SETUP_BREQUEST_SET_CONFIGURATION:

        .wMaxPacketSize      = 0,

                if (buffer->setup.wLength || buffer->setup.wIndex || !data->state->current_address

        .bInterval           = 1

                 || buffer->setup.wValue > data->configuration_count) break;

    },

                usb_unconfigure(data);

    .endpoint2_descriptor =

                data->state->current_configuration = buffer->setup.wValue;

    {

                if (data->state->current_configuration)

        .bLength             = sizeof(struct usb_endpoint_descriptor),

                {

        .bDescriptorType     = USB_DT_ENDPOINT,

                    // Notify the configuration and its interface default altsettings that it should set up stuff

        .bEndpointAddress    = 0,

                    int configid = data->state->current_configuration;

        .bmAttributes        = USB_ENDPOINT_XFER_BULK,

                    const struct usb_configuration* configuration = data->configurations[configid - 1];

        .wMaxPacketSize      = 0,

                    if (configuration->set_configuration)

        .bInterval           = 1

                        configuration->set_configuration(data, configid);

    },

                    int i;

    .endpoint3_descriptor =

                    for (i = 0; i < configuration->interface_count; i++)

    {

                    {

        .bLength             = sizeof(struct usb_endpoint_descriptor),

                        const struct usb_interface* interface = configuration->interfaces[i];

        .bDescriptorType     = USB_DT_ENDPOINT,

                        data->state->interface_altsetting[i] = 0;

        .bEndpointAddress    = 0,

                        const struct usb_altsetting* altsetting = interface->altsettings[0];

        .bmAttributes        = USB_ENDPOINT_XFER_BULK,

                        if (altsetting->set_altsetting) altsetting->set_altsetting(data, i, 0);

        .wMaxPacketSize      = 0,

                    }

        .bInterval           = 1

                }

    },

                size = 0;

    .endpoint4_descriptor =

                break;

    {

            default: break;

        .bLength             = sizeof(struct usb_endpoint_descriptor),

            }

        .bDescriptorType     = USB_DT_ENDPOINT,

            break;

        .bEndpointAddress    = 0,

        }

        .bmAttributes        = USB_ENDPOINT_XFER_BULK,

        break;

        .wMaxPacketSize      = 0,

    case USB_SETUP_BMREQUESTTYPE_RECIPIENT_INTERFACE:

        .bInterval           = 1

    {

    }

        if (!data->state->current_configuration) break;

};

        int configid = data->state->current_configuration;

        const struct usb_configuration* configuration = data->configurations[configid - 1];

static struct usb_string_descriptor string_vendor CACHEALIGN_ATTR =

        int intfid = buffer->setup.wIndex;

{

        if (intfid >= configuration->interface_count) break;

    30,

        const struct usb_interface* interface = configuration->interfaces[intfid];

    USB_DT_STRING,

        if (interface->ctrl_request) size = interface->ctrl_request(data, intfid, buffer, &addr);

    {'f', 'r', 'e', 'e', 'm', 'y', 'i', 'p', 'o', 'd', '.', 'o', 'r', 'g'}

        if (size != -1) break;

};

        switch (buffer->setup.bmRequestType.type)

        {

static struct usb_string_descriptor string_product CACHEALIGN_ATTR =

        case USB_SETUP_BMREQUESTTYPE_TYPE_STANDARD:

{

            switch (buffer->setup.bRequest.req)

    32,

            {

    USB_DT_STRING,

            case USB_SETUP_BREQUEST_GET_STATUS:

    {'e', 'm', 'C', 'O', 'R', 'E', ' ', 'D', 'e', 'b', 'u', 'g', 'g', 'e', 'r'}

                if (buffer->setup.wLength != 2 || buffer->setup.wValue) break;

};

                data->buffer->raw[0] = 0;

                data->buffer->raw[1] = 0;

static const struct usb_string_descriptor lang_descriptor CACHEALIGN_ATTR =

                size = 2;

{

                break;

    4,

            case USB_SETUP_BREQUEST_GET_INTERFACE:

    USB_DT_STRING,

                if (buffer->setup.wLength != 1 || buffer->setup.wValue) break;

    {0x0409}

                data->buffer->raw[0] = data->state->interface_altsetting[intfid];

};

                size = 1;

                break;

            case USB_SETUP_BREQUEST_SET_INTERFACE:

void usb_setup_dbg_listener()

            {

{

                if (buffer->setup.wLength

    usb_drv_recv(dbgendpoints[0], dbgrecvbuf, 512);

                 || buffer->setup.wValue > interface->altsetting_count) break;

}

                const struct usb_altsetting* altsetting = interface->altsettings[data->state->interface_altsetting[intfid]];

                if (altsetting->unset_altsetting)

void usb_handle_control_request(struct usb_ctrlrequest* req)

                    altsetting->unset_altsetting(data, intfid, data->state->interface_altsetting[intfid]);

{

                data->state->interface_altsetting[intfid] = buffer->setup.wValue;

    const void* addr;

                altsetting = interface->altsettings[data->state->interface_altsetting[intfid]];

    int size = -1;

                if (altsetting->set_altsetting)

    switch (req->bRequest)

                    altsetting->set_altsetting(data, intfid, data->state->interface_altsetting[intfid]);

    {

                break;

    case USB_REQ_GET_STATUS:

            }

        if (req->bRequestType == USB_DIR_IN) ctrlresp[0] = 1;

            default: break;

        else ctrlresp[0] = 0;

            }

        ctrlresp[1] = 0;

            break;

        addr = ctrlresp;

            default: break;

        size = 2;

        }

        break;

        break;

    case USB_REQ_CLEAR_FEATURE:

        case USB_SETUP_BMREQUESTTYPE_RECIPIENT_ENDPOINT:

        if (req->bRequestType == USB_RECIP_ENDPOINT && req->wValue == USB_ENDPOINT_HALT)

        {

            usb_drv_stall(req->wIndex & 0xf, false, req->wIndex >> 7);

            if (!data->state->current_configuration) break;

        size = 0;

            union usb_endpoint_number ep = { .byte = buffer->setup.wIndex };

        break;

            int intfid;

    case USB_REQ_SET_FEATURE:

            int epid;

        size = 0;

            const struct usb_endpoint* endpoint = usb_find_endpoint(data, ep, &intfid, &epid);

        break;

            if (!endpoint) break;

    case USB_REQ_SET_ADDRESS:

            if (endpoint->ctrl_request) size = endpoint->ctrl_request(data, intfid, epid, buffer, &addr);

        size = 0;

            if (size != -1) break;

        usb_drv_cancel_all_transfers();

            switch (buffer->setup.bmRequestType.type)

        usb_drv_set_address(req->wValue);

            {

        usb_setup_dbg_listener();

            case USB_SETUP_BMREQUESTTYPE_TYPE_STANDARD:

        break;

                switch (buffer->setup.bRequest.req)

    case USB_REQ_GET_DESCRIPTOR:

                {

        switch (req->wValue >> 8)

                case USB_SETUP_BREQUEST_GET_STATUS:

        {

                    if (buffer->setup.wLength != 2 || buffer->setup.wValue) break;

        case USB_DT_DEVICE:

                    data->buffer->raw[0] = 0;

            addr = &device_descriptor;

                    data->buffer->raw[1] = data->driver->get_stall(data, ep);

            size = sizeof(device_descriptor);

                    addr = data->buffer;

            break;

                    size = 2;

        case USB_DT_OTHER_SPEED_CONFIG:

                    break;

                case USB_SETUP_BREQUEST_CLEAR_FEATURE:

        case USB_DT_CONFIG:

                    if (buffer->setup.wLength || buffer->setup.wValue) break;

            if ((req->wValue >> 8) == USB_DT_CONFIG)

                    data->driver->set_stall(data, ep, false);

            {

                    size = 0;

                int maxpacket = usb_drv_port_speed() ? 512 : 64;

                    break;

                config_bundle.endpoint1_descriptor.wMaxPacketSize = maxpacket;

                case USB_SETUP_BREQUEST_SET_FEATURE:

                config_bundle.endpoint2_descriptor.wMaxPacketSize = maxpacket;

                    if (buffer->setup.wLength || buffer->setup.wValue) break;

                config_bundle.endpoint3_descriptor.wMaxPacketSize = maxpacket;

                    data->driver->set_stall(data, ep, true);

                config_bundle.endpoint4_descriptor.wMaxPacketSize = maxpacket;

                    size = 0;

                config_bundle.config_descriptor.bDescriptorType = USB_DT_CONFIG;

                    break;

            }

                default: break;

            else

                }

            {

                break;

                int maxpacket = usb_drv_port_speed() ? 64 : 512;

                default: break;

                config_bundle.endpoint1_descriptor.wMaxPacketSize = maxpacket;

            }

                config_bundle.endpoint2_descriptor.wMaxPacketSize = maxpacket;

            break;

                config_bundle.endpoint3_descriptor.wMaxPacketSize = maxpacket;

        }

                config_bundle.endpoint4_descriptor.wMaxPacketSize = maxpacket;

        default: break;

                config_bundle.config_descriptor.bDescriptorType = USB_DT_OTHER_SPEED_CONFIG;

    }

            }

    }

            addr = &config_bundle;

    // See comment at the top of this function

            size = sizeof(config_bundle);

    if (size == 0) usb_ep0_start_tx(data, NULL, 0, true, NULL);

            break;

    else if (size > 0)

        case USB_DT_STRING:

    {

            switch (req->wValue & 0xff)

        usb_ep0_start_rx(data, 0, NULL);

            {

        int len = MIN(64, size);

            case 0:

        data->state->ep0_tx_ptr = addr;

                addr = &lang_descriptor;

        data->state->ep0_tx_len = size - len;

                size = lang_descriptor.bLength;

        usb_ep0_start_tx(data, addr, len, !data->state->ep0_tx_len, usb_ep0_tx_callback);

                break;

    }

            case 1:

    else if (size >= -2)

                addr = &string_vendor;

    {

                size = string_vendor.bLength;

        union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };

                break;

        usb_set_stall(data, ep, 1);

            case 2:

        ep.direction = USB_ENDPOINT_DIRECTION_OUT;

                addr = &string_product;

        usb_set_stall(data, ep, 1);

                size = string_product.bLength;

    }

                break;

}

            }

            break;

void usb_handle_bus_reset(const struct usb_instance* data, int highspeed)

        }

{

        break;

    data->state->current_address = 0;

    case USB_REQ_GET_CONFIGURATION:

    usb_unconfigure(data);

        ctrlresp[0] = 1;

    if (data->bus_reset) data->bus_reset(data, highspeed);

        addr = ctrlresp;

    int c, i;

        size = 1;

    for (c = 0; c < data->configuration_count; c++)

        break;

    {

    case USB_REQ_SET_CONFIGURATION:

        const struct usb_configuration* configuration = data->configurations[c];

        usb_drv_cancel_all_transfers();

        for (i = 0; i < configuration->interface_count; i++)

        usb_setup_dbg_listener();

        {

        size = 0;

            const struct usb_interface* interface = configuration->interfaces[i];

        break;

            if (interface->bus_reset) interface->bus_reset(data, c, i, highspeed);

    }

        }

    if (!size) usb_drv_send_nonblocking(0, NULL, 0);

    }

    else if (size == -1)

    {

    // Prime EP0 for the first setup packet.

        usb_drv_stall(0, true, true);

    usb_ep0_start_rx(data, 0, NULL);

        usb_drv_stall(0, true, false);

}

    }

    else

void usb_handle_timeout(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)

    {

{

        usb_drv_recv(0, NULL, 0);

    // If the host doesn't fetch an EP0 IN packet, we can't do much about it.

        usb_drv_send_nonblocking(0, addr, size > req->wLength ? req->wLength : size);

    // This will be recovered by the next SETUP packet.

    }

    if (epnum.number)

}

    {

        int epidx;

bool set_dbgaction(enum dbgaction_t action, int addsize)

        int ifidx;

{

        const struct usb_endpoint* endpoint = usb_find_endpoint(data, epnum, &epidx, &ifidx);

    if (dbgaction != DBGACTION_IDLE)

        if (!endpoint) data->driver->unconfigure_ep(data, epnum);

    {

        else if (endpoint->timeout) endpoint->timeout(data, ifidx, epidx, bytesleft);

        dbgsendbuf[0] = 3;

    }

        usb_drv_send_nonblocking(dbgendpoints[1], dbgsendbuf, 16 + addsize);

}

        return true;

    }

void usb_handle_xfer_complete(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)

    dbgaction = action;

{

    wakeup_signal(&dbgwakeup);

    if (!epnum.number)

    return false;

    {

}

        bool (*callback)(const struct usb_instance* data, int size);

        if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT)

void reset() __attribute__((noreturn));

        {

            callback = data->state->ep0_rx_callback;

void usb_handle_transfer_complete(int endpoint, int dir, int status, int length)

            data->state->ep0_rx_callback = NULL;

{

        }

    void* addr = dbgsendbuf;

        else

    int size = 0;

        {

    if (endpoint == dbgendpoints[0])

            callback = data->state->ep0_tx_callback;

    {

            data->state->ep0_tx_callback = NULL;

#ifdef USB_HAVE_TARGET_SPECIFIC_REQUESTS

        }

        if (dbgrecvbuf[0] >= 0xffff0000)

        if (callback) callback(data, bytesleft);

        {

    }

            if (!set_dbgaction(DBGACTION_TARGETSPECIFIC, 0))

    else

                memcpy(dbgasyncsendbuf, dbgrecvbuf, sizeof(dbgasyncsendbuf));

    {

            usb_setup_dbg_listener();

        int epidx;

            return;

        int ifidx;

        }

        const struct usb_endpoint* endpoint = usb_find_endpoint(data, epnum, &epidx, &ifidx);

#endif

        if (!endpoint) usb_unconfigure_ep(data, epnum);

        switch (dbgrecvbuf[0])

        else if (endpoint->xfer_complete) endpoint->xfer_complete(data, ifidx, epidx, bytesleft);

        {

    }

        case 1:  // GET INFO

}

            dbgsendbuf[0] = 1;

            size = 16;

void usb_handle_setup_received(const struct usb_instance* data, union usb_endpoint_number epnum)

            switch (dbgrecvbuf[1])

{

            {

    if (!epnum.number)

            case 0:  // GET VERSION INFO

    {

                dbgsendbuf[1] = VERSION_SVN_INT;

        if (!data->ep0_setup_hook || !data->ep0_setup_hook(data, data->buffer)) usb_handle_ep0_setup(data, data->buffer);

                dbgsendbuf[2] = VERSION_MAJOR | (VERSION_MINOR << 8)

    }

                              | (VERSION_PATCH << 16) | (2 << 24);

    else

                dbgsendbuf[3] = PLATFORM_ID;

    {

                break;

        int epidx;

            case 1:  // GET PACKET SIZE INFO

        int ifidx;

                dbgsendbuf[1] = 0x02000200;

        const struct usb_endpoint* endpoint = usb_find_endpoint(data, epnum, &epidx, &ifidx);

                dbgsendbuf[2] = usb_drv_get_max_out_size();

        if (!endpoint) usb_unconfigure_ep(data, epnum);

                dbgsendbuf[3] = usb_drv_get_max_in_size();

        else if (endpoint->setup_received) endpoint->setup_received(data, ifidx, epidx);

                break;

    }

            case 2:  // GET USER MEMORY INFO

}

                dbgsendbuf[1] = (uint32_t)&_poolstart;

                dbgsendbuf[2] = (uint32_t)&_poolend;

void usb_init(const struct usb_instance* data)

                break;

{

            default:

    // Initialize data struct

                dbgsendbuf[0] = 2;

    data->state->current_address = 0;

            }

    data->state->current_configuration = 0;

            break;

        case 2:  // RESET

    // Initialize driver

            if (dbgrecvbuf[1])

    data->driver->init(data);

            {

}

                if (set_dbgaction(DBGACTION_RESET, 0)) break;

                dbgsendbuf[0] = 1;

void usb_exit(const struct usb_instance* data)

                size = 16;

{

            }

    // Shut down driver

            else reset();

    data->driver->exit(data);

            break;

        case 3:  // POWER OFF

    // Unconfigure everything

            if (set_dbgaction(DBGACTION_POWEROFF, 0)) break;

    usb_unconfigure(data);

            dbgactiontype = dbgrecvbuf[1];

}

            dbgsendbuf[0] = 1;