rockbox/firmware/usbstack/usb_core.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2007 by Björn Stenberg
 *
 * This program 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 License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "system.h"
#include "thread.h"
#include "kernel.h"
#include "string.h"
#include "panic.h"
/*#define LOGF_ENABLE*/
#include "logf.h"

#include "usb.h"
#include "usb_ch9.h"
#include "usb_drv.h"
#include "usb_core.h"
#include "usb_class_driver.h"

#if defined(USB_ENABLE_STORAGE)
#include "usb_storage.h"
#endif

#if defined(USB_ENABLE_SERIAL)
#include "usb_serial.h"
#endif

#if defined(USB_ENABLE_CHARGING_ONLY)
#include "usb_charging_only.h"
#endif

#ifdef USB_ENABLE_HID
#include "usb_hid.h"
#endif

/* TODO: Move target-specific stuff somewhere else (serial number reading) */

#ifdef HAVE_AS3514
#include "ascodec.h"
#include "as3514.h"
#endif

#if !defined(HAVE_AS3514) && !defined(IPOD_ARCH) && (CONFIG_STORAGE & STORAGE_ATA)
#include "ata.h"
#endif

#if (CONFIG_CPU == IMX233)
#include "ocotp-imx233.h"
#endif

#ifdef SANSA_CONNECT
#include "cryptomem-sansaconnect.h"
#endif

#ifndef USB_MAX_CURRENT
#define USB_MAX_CURRENT 500
#endif

/*-------------------------------------------------------------------------*/
/* USB protocol descriptors: */

static struct usb_device_descriptor __attribute__((aligned(2)))
                                          device_descriptor=
{
    .bLength            = sizeof(struct usb_device_descriptor),
    .bDescriptorType    = USB_DT_DEVICE,
#ifndef USB_NO_HIGH_SPEED
    .bcdUSB             = 0x0200,
#else
    .bcdUSB             = 0x0110,
#endif
    .bDeviceClass       = USB_CLASS_PER_INTERFACE,
    .bDeviceSubClass    = 0,
    .bDeviceProtocol    = 0,
    .bMaxPacketSize0    = 64,
    .idVendor           = USB_VENDOR_ID,
    .idProduct          = USB_PRODUCT_ID,
    .bcdDevice          = 0x0100,
    .iManufacturer      = USB_STRING_INDEX_MANUFACTURER,
    .iProduct           = USB_STRING_INDEX_PRODUCT,
    .iSerialNumber      = USB_STRING_INDEX_SERIAL,
    .bNumConfigurations = 1
} ;

static struct usb_config_descriptor __attribute__((aligned(2)))
                                    config_descriptor =
{
    .bLength             = sizeof(struct usb_config_descriptor),
    .bDescriptorType     = USB_DT_CONFIG,
    .wTotalLength        = 0, /* will be filled in later */
    .bNumInterfaces      = 1,
    .bConfigurationValue = 1,
    .iConfiguration      = 0,
    .bmAttributes        = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
    .bMaxPower           = (USB_MAX_CURRENT + 1) / 2, /* In 2mA units */
};

static const struct usb_qualifier_descriptor __attribute__((aligned(2)))
                                             qualifier_descriptor =
{
    .bLength            = sizeof(struct usb_qualifier_descriptor),
    .bDescriptorType    = USB_DT_DEVICE_QUALIFIER,
    .bcdUSB             = 0x0200,
    .bDeviceClass       = 0,
    .bDeviceSubClass    = 0,
    .bDeviceProtocol    = 0,
    .bMaxPacketSize0    = 64,
    .bNumConfigurations = 1
};

static const struct usb_string_descriptor __attribute__((aligned(2)))
                                    usb_string_iManufacturer =
USB_STRING_INITIALIZER(u"Rockbox.org");

static const struct usb_string_descriptor __attribute__((aligned(2)))
                                    usb_string_iProduct =
USB_STRING_INITIALIZER(u"Rockbox media player");

static struct usb_string_descriptor __attribute__((aligned(2)))
                                    usb_string_iSerial =
USB_STRING_INITIALIZER(u"00000000000000000000000000000000000000000");

/* Generic for all targets */

/* this is stringid #0: languages supported */
static const struct usb_string_descriptor __attribute__((aligned(2)))
                                    lang_descriptor =
USB_STRING_INITIALIZER(u"\x0409"); /* LANGID US English */

static const struct usb_string_descriptor* const usb_strings[USB_STRING_INDEX_MAX] =
{
    [USB_STRING_INDEX_LANGUAGE] = &lang_descriptor,
    [USB_STRING_INDEX_MANUFACTURER] = &usb_string_iManufacturer,
    [USB_STRING_INDEX_PRODUCT] = &usb_string_iProduct,
    [USB_STRING_INDEX_SERIAL] = &usb_string_iSerial,
};

static int usb_address = 0;
static bool initialized = false;
static bool drivers_connected = false;
static enum { DEFAULT, ADDRESS, CONFIGURED } usb_state;

#ifdef HAVE_USB_CHARGING_ENABLE
static int usb_charging_mode = USB_CHARGING_DISABLE;
static int usb_charging_current_requested = 500;
static struct timeout usb_no_host_timeout;
static bool usb_no_host = false;

static int usb_no_host_callback(struct timeout *tmo)
{
    (void)tmo;
    usb_no_host = true;
    usb_charger_update();
    return 0;
}
#endif

static int usb_core_num_interfaces;

typedef void (*completion_handler_t)(int ep, int dir, int status, int length);
typedef bool (*control_handler_t)(struct usb_ctrlrequest* req, void* reqdata,
    unsigned char* dest);

static struct
{
    completion_handler_t completion_handler[2];
    control_handler_t control_handler[2];
    struct usb_transfer_completion_event_data completion_event[2];
} ep_data[USB_NUM_ENDPOINTS];

static struct usb_class_driver drivers[USB_NUM_DRIVERS] =
{
#ifdef USB_ENABLE_STORAGE
    [USB_DRIVER_MASS_STORAGE] = {
        .enabled = false,
        .needs_exclusive_storage = true,
        .first_interface = 0,
        .last_interface = 0,
        .request_endpoints = usb_storage_request_endpoints,
        .set_first_interface = usb_storage_set_first_interface,
        .get_config_descriptor = usb_storage_get_config_descriptor,
        .init_connection = usb_storage_init_connection,
        .init = usb_storage_init,
        .disconnect = usb_storage_disconnect,
        .transfer_complete = usb_storage_transfer_complete,
        .control_request = usb_storage_control_request,
#ifdef HAVE_HOTSWAP
        .notify_hotswap = usb_storage_notify_hotswap,
#endif
    },
#endif
#ifdef USB_ENABLE_SERIAL
    [USB_DRIVER_SERIAL] = {
        .enabled = false,
        .needs_exclusive_storage = false,
        .first_interface = 0,
        .last_interface = 0,
        .request_endpoints = usb_serial_request_endpoints,
        .set_first_interface = usb_serial_set_first_interface,
        .get_config_descriptor = usb_serial_get_config_descriptor,
        .init_connection = usb_serial_init_connection,
        .init = usb_serial_init,
        .disconnect = usb_serial_disconnect,
        .transfer_complete = usb_serial_transfer_complete,
        .control_request = usb_serial_control_request,
#ifdef HAVE_HOTSWAP
        .notify_hotswap = NULL,
#endif
    },
#endif
#ifdef USB_ENABLE_CHARGING_ONLY
    [USB_DRIVER_CHARGING_ONLY] = {
        .enabled = false,
        .needs_exclusive_storage = false,
        .first_interface = 0,
        .last_interface = 0,
        .request_endpoints = usb_charging_only_request_endpoints,
        .set_first_interface = usb_charging_only_set_first_interface,
        .get_config_descriptor = usb_charging_only_get_config_descriptor,
        .init_connection = NULL,
        .init = NULL,
        .disconnect = NULL,
        .transfer_complete = NULL,
        .control_request = NULL,
#ifdef HAVE_HOTSWAP
        .notify_hotswap = NULL,
#endif
    },
#endif
#ifdef USB_ENABLE_HID
    [USB_DRIVER_HID] = {
        .enabled = false,
        .needs_exclusive_storage = false,
        .first_interface = 0,
        .last_interface = 0,
        .request_endpoints = usb_hid_request_endpoints,
        .set_first_interface = usb_hid_set_first_interface,
        .get_config_descriptor = usb_hid_get_config_descriptor,
        .init_connection = usb_hid_init_connection,
        .init = usb_hid_init,
        .disconnect = usb_hid_disconnect,
        .transfer_complete = usb_hid_transfer_complete,
        .control_request = usb_hid_control_request,
#ifdef HAVE_HOTSWAP
        .notify_hotswap = NULL,
#endif
    },
#endif
};

#ifdef USB_LEGACY_CONTROL_API
static struct usb_ctrlrequest* volatile active_request = NULL;
static void* volatile control_write_data = NULL;
static volatile bool control_write_data_done = false;
#endif

static void usb_core_control_request_handler(struct usb_ctrlrequest* req, void* reqdata);

static unsigned char response_data[256] USB_DEVBSS_ATTR;

/** NOTE Serial Number
 * The serial number string is split into two parts:
 * - the first character indicates the set of interfaces enabled
 * - the other characters form a (hopefully) unique device-specific number
 * The implementation of set_serial_descriptor should left the first character
 * of usb_string_iSerial unused, ie never write to
 * usb_string_iSerial.wString[0] but should take it into account when
 * computing the length of the descriptor
 */

static const short hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                        '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
#ifdef IPOD_ARCH
static void set_serial_descriptor(void)
{
#ifdef IPOD_VIDEO
    uint32_t* serial = (uint32_t*)0x20004034;
#else
    uint32_t* serial = (uint32_t*)0x20002034;
#endif

    /* We need to convert from a little-endian 64-bit int
       into a utf-16 string of hex characters */
    short* p = &usb_string_iSerial.wString[24];
    uint32_t x;
    int i, j;

    for(i = 0; i < 2; i++) {
       x = serial[i];
       for(j = 0; j < 8; j++) {
          *p-- = hex[x & 0xf];
          x >>= 4;
       }
    }
    usb_string_iSerial.bLength = 52;
}
#elif defined(HAVE_AS3514)
static void set_serial_descriptor(void)
{
    unsigned char serial[AS3514_UID_LEN];
    /* Align 32 digits right in the 40-digit serial number */
    short* p = &usb_string_iSerial.wString[1];
    int i;

    ascodec_readbytes(AS3514_UID_0, AS3514_UID_LEN, serial);
    for(i = 0; i < AS3514_UID_LEN; i++) {
        *p++ = hex[(serial[i] >> 4) & 0xF];
        *p++ = hex[(serial[i] >> 0) & 0xF];
    }
    usb_string_iSerial.bLength = 36 + (2 * AS3514_UID_LEN);
}
#elif (CONFIG_CPU == IMX233) && IMX233_SUBTARGET >= 3700
// FIXME where is the STMP3600 serial number stored ?
static void set_serial_descriptor(void)
{
    short* p = &usb_string_iSerial.wString[1];
    for(int i = 0; i < IMX233_NUM_OCOTP_OPS; i++) {
        uint32_t ops = imx233_ocotp_read(&HW_OCOTP_OPSn(i));
        for(int j = 0; j < 8; j++) {
            *p++ = hex[(ops >> 28) & 0xF];
            ops <<= 4;
        }
    }
    usb_string_iSerial.bLength = 2 + 2 * (1 + IMX233_NUM_OCOTP_OPS * 8);
}
#elif defined(SANSA_CONNECT)
static void set_serial_descriptor(void)
{
    char deviceid[32];
    short* p = &usb_string_iSerial.wString[1];
    int i;

    if(!cryptomem_read_deviceid(deviceid)) {
        for(i = 0; i < 32; i++) {
            *p++ = deviceid[i];
        }
        usb_string_iSerial.bLength = 2 + 2 * (1 + 32);
    } else {
        device_descriptor.iSerialNumber = 0;
    }
}
#elif (CONFIG_STORAGE & STORAGE_ATA)
/* If we don't know the device serial number, use the one
 * from the disk */
static void set_serial_descriptor(void)
{
    short* p = &usb_string_iSerial.wString[1];
    unsigned short* identify = ata_get_identify();
    unsigned short x;
    int i;

    for(i = 10; i < 20; i++) {
       x = identify[i];
       *p++ = hex[(x >> 12) & 0xF];
       *p++ = hex[(x >> 8) & 0xF];
       *p++ = hex[(x >> 4) & 0xF];
       *p++ = hex[(x >> 0) & 0xF];
    }
    usb_string_iSerial.bLength = 84;
}
#elif (CONFIG_STORAGE & STORAGE_RAMDISK)
/* This "serial number" isn't unique, but it should never actually
   appear in non-testing use */
static void set_serial_descriptor(void)
{
    short* p = &usb_string_iSerial.wString[1];
    int i;
    for(i = 0; i < 16; i++) {
        *p++ = hex[(2 * i) & 0xF];
        *p++ = hex[(2 * i + 1) & 0xF];
    }
    usb_string_iSerial.bLength = 68;
}
#else
static void set_serial_descriptor(void)
{
    device_descriptor.iSerialNumber = 0;
}
#endif

void usb_core_init(void)
{
    int i;
    if (initialized)
        return;

    usb_drv_init();

    /* class driver init functions should be safe to call even if the driver
     * won't be used. This simplifies other logic (i.e. we don't need to know
     * yet which drivers will be enabled */
    for(i = 0; i < USB_NUM_DRIVERS; i++)
        if(drivers[i].init != NULL)
            drivers[i].init();

    initialized = true;
    usb_state = DEFAULT;
#ifdef HAVE_USB_CHARGING_ENABLE
    usb_no_host = false;
    timeout_register(&usb_no_host_timeout, usb_no_host_callback, HZ*10, 0);
#endif
    logf("usb_core_init() finished");
}

void usb_core_exit(void)
{
    int i;
    if(drivers_connected)
    {
        for(i = 0; i < USB_NUM_DRIVERS; i++)
            if(drivers[i].enabled && drivers[i].disconnect != NULL)
            {
                drivers[i].disconnect();
                drivers[i].enabled = false;
            }
        drivers_connected = false;
    }

    if(initialized) {
        usb_drv_exit();
        initialized = false;
    }
    usb_state = DEFAULT;
#ifdef HAVE_USB_CHARGING_ENABLE
    usb_no_host = false;
    usb_charging_maxcurrent_change(usb_charging_maxcurrent());
#endif
    logf("usb_core_exit() finished");
}

void usb_core_handle_transfer_completion(
    struct usb_transfer_completion_event_data* event)
{
    completion_handler_t handler;
    int ep = event->endpoint;

    switch(ep) {
        case EP_CONTROL:
            logf("ctrl handled %ld req=0x%x",
                 current_tick,
                 ((struct usb_ctrlrequest*)event->data[0])->bRequest);

            usb_core_control_request_handler(
                (struct usb_ctrlrequest*)event->data[0], event->data[1]);
            break;
        default:
            handler = ep_data[ep].completion_handler[EP_DIR(event->dir)];
            if(handler != NULL)
                handler(ep, event->dir, event->status, event->length);
            break;
    }
}

void usb_core_enable_driver(int driver, bool enabled)
{
    drivers[driver].enabled = enabled;
}

bool usb_core_driver_enabled(int driver)
{
    return drivers[driver].enabled;
}

bool usb_core_any_exclusive_storage(void)
{
    int i;
    for(i = 0; i < USB_NUM_DRIVERS; i++)
        if(drivers[i].enabled && drivers[i].needs_exclusive_storage)
            return true;

    return false;
}

#ifdef HAVE_HOTSWAP
void usb_core_hotswap_event(int volume, bool inserted)
{
    int i;
    for(i = 0; i < USB_NUM_DRIVERS; i++)
        if(drivers[i].enabled && drivers[i].notify_hotswap != NULL)
            drivers[i].notify_hotswap(volume, inserted);
}
#endif

static void usb_core_set_serial_function_id(void)
{
    int i, id = 0;
    
    for(i = 0; i < USB_NUM_DRIVERS; i++)
        if(drivers[i].enabled)
            id |= 1 << i;
    
    usb_string_iSerial.wString[0] = hex[id];
}

int usb_core_request_endpoint(int type, int dir, struct usb_class_driver* drv)
{
    int ret, ep;

    ret = usb_drv_request_endpoint(type, dir);

    if(ret == -1)
        return -1;

    dir = EP_DIR(ret);
    ep = EP_NUM(ret);

    ep_data[ep].completion_handler[dir] = drv->transfer_complete;
    ep_data[ep].control_handler[dir] = drv->control_request;

    return ret;
}

void usb_core_release_endpoint(int ep)
{
    int dir;

    usb_drv_release_endpoint(ep);

    dir = EP_DIR(ep);
    ep = EP_NUM(ep);

    ep_data[ep].completion_handler[dir] = NULL;
    ep_data[ep].control_handler[dir] = NULL;
}

static void allocate_interfaces_and_endpoints(void)
{
    int i;
    int interface = 0;

    memset(ep_data, 0, sizeof(ep_data));

    for(i = 0; i < USB_NUM_ENDPOINTS; i++) {
        usb_drv_release_endpoint(i | USB_DIR_OUT);
        usb_drv_release_endpoint(i | USB_DIR_IN);
    }

    for(i = 0; i < USB_NUM_DRIVERS; i++) {
        if(drivers[i].enabled) {
            drivers[i].first_interface = interface;

            if(drivers[i].request_endpoints(&drivers[i])) {
                drivers[i].enabled = false;
                continue;
            }

            interface = drivers[i].set_first_interface(interface);
            drivers[i].last_interface = interface;
        }
    }
    usb_core_num_interfaces = interface;
}


static void control_request_handler_drivers(struct usb_ctrlrequest* req, void* reqdata)
{
    int i, interface = req->wIndex & 0xff;
    bool handled = false;

    for(i = 0; i < USB_NUM_DRIVERS; i++) {
        if(drivers[i].enabled &&
                drivers[i].control_request &&
                drivers[i].first_interface <= interface &&
                drivers[i].last_interface > interface)
        {
            handled = drivers[i].control_request(req, reqdata, response_data);
            if(handled)
                break;
        }
    }
    if(!handled) {
        /* nope. flag error */
        logf("bad req:desc %d:%d", req->bRequest, req->wValue >> 8);
        usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
    }
}

static void request_handler_device_get_descriptor(struct usb_ctrlrequest* req, void* reqdata)
{
    int size;
    const void* ptr = NULL;
    int length = req->wLength;
    int index = req->wValue & 0xff;

    switch(req->wValue >> 8) { /* type */
        case USB_DT_DEVICE:
            ptr = &device_descriptor;
            size = sizeof(struct usb_device_descriptor);
            break;

        case USB_DT_OTHER_SPEED_CONFIG:
        case USB_DT_CONFIG: {
                int i, max_packet_size;

                if(req->wValue>>8==USB_DT_CONFIG) {
                    max_packet_size = (usb_drv_port_speed() ? 512 : 64);
                    config_descriptor.bDescriptorType = USB_DT_CONFIG;
                }
                else {
                    max_packet_size=(usb_drv_port_speed() ? 64 : 512);
                    config_descriptor.bDescriptorType =
                        USB_DT_OTHER_SPEED_CONFIG;
                }
#ifdef HAVE_USB_CHARGING_ENABLE
                if (usb_charging_mode == USB_CHARGING_DISABLE) {
                    config_descriptor.bMaxPower = (100+1)/2;
                    usb_charging_current_requested = 100;
                }
                else {
                    config_descriptor.bMaxPower = (500+1)/2;
                    usb_charging_current_requested = 500;
                }
#endif
                size = sizeof(struct usb_config_descriptor);

                for(i = 0; i < USB_NUM_DRIVERS; i++)
                    if(drivers[i].enabled && drivers[i].get_config_descriptor)
                        size += drivers[i].get_config_descriptor(
                                    &response_data[size], max_packet_size);

                config_descriptor.bNumInterfaces = usb_core_num_interfaces;
                config_descriptor.wTotalLength = (uint16_t)size;
                memcpy(&response_data[0], &config_descriptor,
                        sizeof(struct usb_config_descriptor));

                ptr = response_data;
                break;
            }

        case USB_DT_STRING:
            logf("STRING %d", index);
            if((unsigned)index < USB_STRING_INDEX_MAX) {
                size = usb_strings[index]->bLength;
                ptr = usb_strings[index];
            }
            else if(index == 0xee) {
                /* We don't have a real OS descriptor, and we don't handle
                 * STALL correctly on some devices, so we return any valid
                 * string (we arbitrarily pick the manufacturer name)
                 */
                size = usb_string_iManufacturer.bLength;
                ptr = &usb_string_iManufacturer;
            }
            else {
                logf("bad string id %d", index);
                ptr = NULL;
            }
            break;

        case USB_DT_DEVICE_QUALIFIER:
            ptr = &qualifier_descriptor;
            size = sizeof(struct usb_qualifier_descriptor);
            break;

        default:
            logf("ctrl desc.");
            control_request_handler_drivers(req, reqdata);
            return;
    }

    if(ptr) {
        logf("data %d (%d)", size, length);
        length = MIN(size, length);

        if (ptr != response_data)
            memcpy(response_data, ptr, length);

        usb_drv_control_response(USB_CONTROL_ACK, response_data, length);
    } else {
        usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
    }
}

static void usb_core_do_set_addr(uint8_t address)
{
    logf("usb_core: SET_ADR %d", address);
    usb_address = address;
    usb_state = ADDRESS;
}

static void usb_core_do_set_config(uint8_t config)
{
    logf("usb_core: SET_CONFIG %d",config);
    if(config) {
        usb_state = CONFIGURED;

        if(drivers_connected)
            for(int i = 0; i < USB_NUM_DRIVERS; i++)
                if(drivers[i].enabled && drivers[i].disconnect != NULL)
                    drivers[i].disconnect();

        for(int i = 0; i < USB_NUM_DRIVERS; i++)
            if(drivers[i].enabled && drivers[i].init_connection)
                drivers[i].init_connection();
        drivers_connected = true;
    }
    else
        usb_state = ADDRESS;
    #ifdef HAVE_USB_CHARGING_ENABLE
    usb_charging_maxcurrent_change(usb_charging_maxcurrent());
    #endif
}

static void usb_core_do_clear_feature(int recip, int recip_nr, int feature)
{
    logf("usb_core: CLEAR FEATURE (%d,%d,%d)", recip, recip_nr, feature);
    if(recip == USB_RECIP_ENDPOINT)
    {
        if(feature == USB_ENDPOINT_HALT)
            usb_drv_stall(EP_NUM(recip_nr), false, EP_DIR(recip_nr));
    }
}

static void request_handler_device(struct usb_ctrlrequest* req, void* reqdata)
{
    unsigned address;

    switch(req->bRequest) {
        case USB_REQ_GET_CONFIGURATION:
            logf("usb_core: GET_CONFIG");
            response_data[0] = (usb_state == ADDRESS ? 0 : 1);
            usb_drv_control_response(USB_CONTROL_ACK, response_data, 1);
            break;
        case USB_REQ_SET_CONFIGURATION:
            usb_drv_cancel_all_transfers();
            usb_core_do_set_config(req->wValue);
            usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
            break;
        case USB_REQ_SET_ADDRESS:
            /* NOTE: We really have no business handling this and drivers
             * should just handle it themselves. We don't care beyond
             * knowing if we've been assigned an address yet, or not. */
            address = req->wValue;
            usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
            usb_drv_cancel_all_transfers();
            usb_drv_set_address(address);
            usb_core_do_set_addr(address);
            break;
        case USB_REQ_GET_DESCRIPTOR:
            logf("usb_core: GET_DESC %d", req->wValue >> 8);
            request_handler_device_get_descriptor(req, reqdata);
            break;
        case USB_REQ_SET_FEATURE:
            if(req->wValue==USB_DEVICE_TEST_MODE) {
                int mode = req->wIndex >> 8;
                usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
                usb_drv_set_test_mode(mode);
            } else {
                usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            }
            break;
        case USB_REQ_GET_STATUS:
            response_data[0] = 0;
            response_data[1] = 0;
            usb_drv_control_response(USB_CONTROL_ACK, response_data, 2);
            break;
        default:
            logf("bad req:desc %d:%d", req->bRequest, req->wValue);
            usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            break;
    }
}

static void request_handler_interface_standard(struct usb_ctrlrequest* req, void* reqdata)
{
    switch (req->bRequest)
    {
        case USB_REQ_SET_INTERFACE:
            logf("usb_core: SET_INTERFACE");
            usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
            break;

        case USB_REQ_GET_INTERFACE:
            logf("usb_core: GET_INTERFACE");
            response_data[0] = 0;
            usb_drv_control_response(USB_CONTROL_ACK, response_data, 1);
            break;
        case USB_REQ_GET_STATUS:
            response_data[0] = 0;
            response_data[1] = 0;
            usb_drv_control_response(USB_CONTROL_ACK, response_data, 2);
            break;
        case USB_REQ_CLEAR_FEATURE:
        case USB_REQ_SET_FEATURE:
            /* TODO: These used to be ignored (erroneously).
             * Should they be passed to the drivers instead? */
            usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            break;
        default:
            control_request_handler_drivers(req, reqdata);
            break;
    }
}

static void request_handler_interface(struct usb_ctrlrequest* req, void* reqdata)
{
    switch(req->bRequestType & USB_TYPE_MASK) {
        case USB_TYPE_STANDARD:
            request_handler_interface_standard(req, reqdata);
            break;
        case USB_TYPE_CLASS:
            control_request_handler_drivers(req, reqdata);
            break;
        case USB_TYPE_VENDOR:
        default:
            logf("bad req:desc %d", req->bRequest);
            usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            break;
    }
}

static void request_handler_endpoint_drivers(struct usb_ctrlrequest* req, void* reqdata)
{
    bool handled = false;
    control_handler_t control_handler = NULL;

    if(EP_NUM(req->wIndex) < USB_NUM_ENDPOINTS)
        control_handler =
            ep_data[EP_NUM(req->wIndex)].control_handler[EP_DIR(req->wIndex)];
    
    if(control_handler)
        handled = control_handler(req, reqdata, response_data);
    
    if(!handled) {
        /* nope. flag error */
        logf("usb bad req %d", req->bRequest);
        usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
    }
}

static void request_handler_endpoint_standard(struct usb_ctrlrequest* req, void* reqdata)
{
    switch (req->bRequest) {
        case USB_REQ_CLEAR_FEATURE:
            usb_core_do_clear_feature(USB_RECIP_ENDPOINT,
                                      req->wIndex,
                                      req->wValue);
            usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
            break;
        case USB_REQ_SET_FEATURE:
            logf("usb_core: SET FEATURE (%d)", req->wValue);
            if(req->wValue == USB_ENDPOINT_HALT)
               usb_drv_stall(EP_NUM(req->wIndex), true, EP_DIR(req->wIndex));

            usb_drv_control_response(USB_CONTROL_ACK, NULL, 0);
            break;
        case USB_REQ_GET_STATUS:
            response_data[0] = 0;
            response_data[1] = 0;
            logf("usb_core: GET_STATUS");
            if(req->wIndex > 0)
                response_data[0] = usb_drv_stalled(EP_NUM(req->wIndex),
                                                    EP_DIR(req->wIndex));

            usb_drv_control_response(USB_CONTROL_ACK, response_data, 2);
            break;
        default:
            request_handler_endpoint_drivers(req, reqdata);
            break;
    }
}

static void request_handler_endpoint(struct usb_ctrlrequest* req, void* reqdata)
{
    switch(req->bRequestType & USB_TYPE_MASK) {
        case USB_TYPE_STANDARD:
            request_handler_endpoint_standard(req, reqdata);
            break;
        case USB_TYPE_CLASS:
            request_handler_endpoint_drivers(req, reqdata);
            break;
        case USB_TYPE_VENDOR:
        default:
            logf("bad req:desc %d", req->bRequest);
            usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            break;
    }
}

/* Handling USB requests starts here */
static void usb_core_control_request_handler(struct usb_ctrlrequest* req, void* reqdata)
{
#ifdef HAVE_USB_CHARGING_ENABLE
    timeout_cancel(&usb_no_host_timeout);
    if(usb_no_host) {
        usb_no_host = false;
        usb_charging_maxcurrent_change(usb_charging_maxcurrent());
    }
#endif
    if(usb_state == DEFAULT) {
        set_serial_descriptor();
        usb_core_set_serial_function_id();

        allocate_interfaces_and_endpoints();
    }

    switch(req->bRequestType & USB_RECIP_MASK) {
        case USB_RECIP_DEVICE:
            request_handler_device(req, reqdata);
            break;
        case USB_RECIP_INTERFACE:
            request_handler_interface(req, reqdata);
            break;
        case USB_RECIP_ENDPOINT:
            request_handler_endpoint(req, reqdata);
            break;
        default:
            logf("unsupported recipient");
            usb_drv_control_response(USB_CONTROL_STALL, NULL, 0);
            break;
    }
}

/* called by usb_drv_int() */
void usb_core_bus_reset(void)
{
    logf("usb_core: bus reset");
    usb_address = 0;
    usb_state = DEFAULT;
#ifdef HAVE_USB_CHARGING_ENABLE
#ifdef HAVE_USB_CHARGING_IN_THREAD
    /* On some targets usb_charging_maxcurrent_change() cannot be called
     * from an interrupt handler; get the USB thread to do it instead. */
    usb_charger_update();
#else
    usb_charging_maxcurrent_change(usb_charging_maxcurrent());
#endif
#endif
}

/* called by usb_drv_transfer_completed() */
void usb_core_transfer_complete(int endpoint, int dir, int status, int length)
{
    struct usb_transfer_completion_event_data* completion_event =
        &ep_data[endpoint].completion_event[EP_DIR(dir)];

    void* data0 = NULL;
    void* data1 = NULL;

#ifdef USB_LEGACY_CONTROL_API
    if(endpoint == EP_CONTROL) {
        bool cwdd = control_write_data_done;
        struct usb_ctrlrequest* req = active_request;

        if(dir == USB_DIR_OUT && req && cwdd) {
            data0 = req;
            data1 = control_write_data;
        } else {
            return;
        }
    }
#endif

    completion_event->endpoint = endpoint;
    completion_event->dir = dir;
    completion_event->data[0] = data0;
    completion_event->data[1] = data1;
    completion_event->status = status;
    completion_event->length = length;

    usb_signal_transfer_completion(completion_event);
}

void usb_core_handle_notify(long id, intptr_t data)
{
    switch(id)
    {
        case USB_NOTIFY_SET_ADDR:
            usb_core_do_set_addr(data);
            break;
        case USB_NOTIFY_SET_CONFIG:
            usb_core_do_set_config(data);
            break;
        default:
            break;
    }
}

void usb_core_control_request(struct usb_ctrlrequest* req, void* reqdata)
{
    struct usb_transfer_completion_event_data* completion_event =
        &ep_data[EP_CONTROL].completion_event[EP_DIR(USB_DIR_IN)];

    completion_event->endpoint = EP_CONTROL;
    completion_event->dir = 0;
    completion_event->data[0] = (void*)req;
    completion_event->data[1] = reqdata;
    completion_event->status = 0;
    completion_event->length = 0;
    logf("ctrl received %ld, req=0x%x", current_tick, req->bRequest);
    usb_signal_transfer_completion(completion_event);
}

void usb_core_control_complete(int status)
{
    /* We currently don't use this, it's here to make the API look good ;)
     * It makes sense to #define it away on normal builds.
     */
    (void)status;
    logf("ctrl complete %ld, %d", current_tick, status);
}

#ifdef USB_LEGACY_CONTROL_API
/* Only needed if the driver does not support the new API yet */
void usb_core_legacy_control_request(struct usb_ctrlrequest* req)
{
    active_request = req;
    control_write_data = NULL;
    control_write_data_done = false;

    usb_core_control_request(req, NULL);
}

void usb_drv_control_response(enum usb_control_response resp,
                              void* data, int length)
{
    struct usb_ctrlrequest* req = active_request;

    if(!req)
        panicf("null ctrl req");

    if(req->wLength == 0)
    {
        active_request = NULL;

        /* No-data request */
        if(resp == USB_CONTROL_ACK)
            usb_drv_send(EP_CONTROL, data, length);
        else if(resp == USB_CONTROL_STALL)
            usb_drv_stall(EP_CONTROL, true, true);
        else
            panicf("RECEIVE on non-data req");
    }
    else if(req->bRequestType & USB_DIR_IN)
    {
        /* Control read request */
        if(resp == USB_CONTROL_ACK)
        {
            active_request = NULL;
            usb_drv_recv_nonblocking(EP_CONTROL, NULL, 0);
            usb_drv_send(EP_CONTROL, data, length);
        }
        else if(resp == USB_CONTROL_STALL)
        {
            active_request = NULL;
            usb_drv_stall(EP_CONTROL, true, true);
        }
        else
        {
            panicf("RECEIVE on ctrl read req");
        }
    }
    else if(!control_write_data_done)
    {
        /* Control write request, data phase */
        if(resp == USB_CONTROL_RECEIVE)
        {
            control_write_data = data;
            control_write_data_done = true;
            usb_drv_recv_nonblocking(EP_CONTROL, data, length);
        }
        else if(resp == USB_CONTROL_STALL)
        {
            /* We should stall the OUT endpoint here, but the old code did
             * not do so and some drivers may not handle it correctly. */
            active_request = NULL;
            usb_drv_stall(EP_CONTROL, true, true);
        }
        else
        {
            panicf("ACK on ctrl write data");
        }
    }
    else
    {
        active_request = NULL;
        control_write_data = NULL;
        control_write_data_done = false;

        /* Control write request, status phase */
        if(resp == USB_CONTROL_ACK)
            usb_drv_send(EP_CONTROL, NULL, 0);
        else if(resp == USB_CONTROL_STALL)
            usb_drv_stall(EP_CONTROL, true, true);
        else
            panicf("RECEIVE on ctrl write status");
    }
}
#endif

void usb_core_notify_set_address(uint8_t addr)
{
    logf("notify set addr received %ld", current_tick);
    usb_signal_notify(USB_NOTIFY_SET_ADDR, addr);
}

void usb_core_notify_set_config(uint8_t config)
{
    logf("notify set config received %ld", current_tick);
    usb_signal_notify(USB_NOTIFY_SET_CONFIG, config);
}

#ifdef HAVE_USB_CHARGING_ENABLE
void usb_charging_enable(int state)
{
    usb_charging_mode = state;
    usb_charging_maxcurrent_change(usb_charging_maxcurrent());
}

int usb_charging_maxcurrent()
{
    if (!initialized || usb_charging_mode == USB_CHARGING_DISABLE)
        return 100;
    if (usb_state == CONFIGURED)
        return usb_charging_current_requested;
    if (usb_charging_mode == USB_CHARGING_FORCE && usb_no_host)
        return 500;
    return 100;
}
#endif