Subversion Repositories freemyipod

#include "global.h"
#include "usbglue.h"
#include "usb.h"
#include "usbdebug.h"
#include "util.h"
#include "thread.h"
#include "malloc.h"
#include USB_DRIVER_HEADER

static const struct usb_devicedescriptor usb_devicedescriptor =
{
    .bLength = sizeof(struct usb_devicedescriptor),
    .bDescriptorType = USB_DESCRIPTOR_TYPE_DEVICE,
    .bcdUSB = 0x0200,
    .bDeviceClass = 0,
    .bDeviceSubClass = 0,
    .bDeviceProtocol = 0,
    .bMaxPacketSize0 = 64,
    .idVendor = 0xffff,
    .idProduct = 0xe000,
    .bcdDevice = 2,
    .iManufacturer = 1,
    .iProduct = 2,
    .iSerialNumber = 0,
    .bNumConfigurations = 1,
};

static struct __attribute__((packed)) _usb_config1_descriptors
{
    struct usb_configurationdescriptor c1;
    struct usb_interfacedescriptor c1_i0_a0;
    struct usb_endpointdescriptor c1_i0_a0_e1out;
    struct usb_endpointdescriptor c1_i0_a0_e1in;
} usb_config1_descriptors =
{
    .c1 =
    {
        .bLength = sizeof(struct usb_configurationdescriptor),
        .bDescriptorType = USB_DESCRIPTOR_TYPE_CONFIGURATION,
        .wTotalLength = sizeof(struct _usb_config1_descriptors),
        .bNumInterfaces = 1,
        .bConfigurationValue = 1,
        .iConfiguration = 0,
        .bmAttributes = { .buspowered = 1, .selfpowered = 1 },
        .bMaxPower = USB_MAXCURRENT / 2,
    },
    .c1_i0_a0 =
    {
        .bLength = sizeof(struct usb_interfacedescriptor),
        .bDescriptorType = USB_DESCRIPTOR_TYPE_INTERFACE,
        .bInterfaceNumber = 0,
        .bAlternateSetting = 0,
        .bNumEndpoints = 2,
        .bInterfaceClass = 0xff,
        .bInterfaceSubClass = 0x00,
        .bInterfaceProtocol = 0x00,
        .iInterface = 0,
    },
    .c1_i0_a0_e1out =
    {
        .bLength = sizeof(struct usb_endpointdescriptor),
        .bDescriptorType = USB_DESCRIPTOR_TYPE_ENDPOINT,
        .bEndpointAddress = { .number = USBDEBUG_ENDPOINT_OUT, .direction = USB_ENDPOINT_DIRECTION_OUT },
        .bmAttributes = { .type = USB_ENDPOINT_ATTRIBUTE_TYPE_BULK },
        .wMaxPacketSize = 512,
        .bInterval = 1,
    },
    .c1_i0_a0_e1in =
    {
        .bLength = sizeof(struct usb_endpointdescriptor),
        .bDescriptorType = USB_DESCRIPTOR_TYPE_ENDPOINT,
        .bEndpointAddress = { .number = USBDEBUG_ENDPOINT_IN, .direction = USB_ENDPOINT_DIRECTION_IN },
        .bmAttributes = { .type = USB_ENDPOINT_ATTRIBUTE_TYPE_BULK },
        .wMaxPacketSize = 512,
        .bInterval = 1,
    },
};

static const struct usb_interfacedescriptor usb_simpledebug_intf_desc =
{
    .bLength = sizeof(struct usb_interfacedescriptor),
    .bDescriptorType = USB_DESCRIPTOR_TYPE_INTERFACE,
    .bInterfaceNumber = 0,
    .bAlternateSetting = 0,
    .bNumEndpoints = 0,
    .bInterfaceClass = 0xff,
    .bInterfaceSubClass = 0x00,
    .bInterfaceProtocol = 0x00,
    .iInterface = 0,
};

static const struct usb_stringdescriptor usb_string_language =
{
    .bLength = sizeof(usb_string_language) + sizeof(*usb_string_language.wString),
    .bDescriptorType = USB_DESCRIPTOR_TYPE_STRING,
    .wString = { 0x0409 },
};

static const struct usb_stringdescriptor usb_string_vendor =
{
    .bLength = sizeof(usb_string_vendor) + sizeof(*usb_string_vendor.wString) * 14,
    .bDescriptorType = USB_DESCRIPTOR_TYPE_STRING,
    .wString = { 'f', 'r', 'e', 'e', 'm', 'y', 'i', 'p', 'o', 'd', '.', 'o', 'r', 'g' },
};

static const struct usb_stringdescriptor usb_string_product =
{
    .bLength = sizeof(usb_string_product) + sizeof(*usb_string_product.wString) * 15,
    .bDescriptorType = USB_DESCRIPTOR_TYPE_STRING,
    .wString = { 'e', 'm', 'C', 'O', 'R', 'E', ' ', 'd', 'e', 'b', 'u', 'g', 'g', 'e', 'r' },
};

static const struct usb_stringdescriptor* usb_stringdescriptors[] =
{
    &usb_string_language,
    &usb_string_vendor,
    &usb_string_product,
};

static const struct usb_endpoint usb_c1_i0_a0_ep1out =
{
    .number = { .number = USBDEBUG_ENDPOINT_OUT, .direction = USB_ENDPOINT_DIRECTION_OUT },
    .ctrl_request = usbdebug_bulk_ctrl_request,
    .xfer_complete = usbdebug_bulk_xfer_complete,
    .setup_received = NULL,
};

static const struct usb_endpoint usb_c1_i0_a0_ep1in =
{
    .number = { .number = USBDEBUG_ENDPOINT_IN, .direction = USB_ENDPOINT_DIRECTION_IN },
    .ctrl_request = usbdebug_bulk_ctrl_request,
    .xfer_complete = usbdebug_bulk_xfer_complete,
    .timeout = NULL,
};

static const struct usb_altsetting usb_c1_i0_a0 =
{
    .set_altsetting = usbdebug_bulk_enable,
    .unset_altsetting = usbdebug_bulk_disable,
    .endpoint_count = 2,
    .endpoints =
    {
        &usb_c1_i0_a0_ep1out,
        &usb_c1_i0_a0_ep1in,
    },
};

static void usbglue_bus_reset(const struct usb_instance* data, int highspeed)
{
    usb_config1_descriptors.c1_i0_a0_e1out.wMaxPacketSize = highspeed ? 512 : 64;
    usb_config1_descriptors.c1_i0_a0_e1in.wMaxPacketSize = highspeed ? 512 : 64;
}

static struct usb_interface usb_c1_i0 =
{
    .bus_reset = usbdebug_bus_reset,
    .ctrl_request = usbdebug_handle_setup,
    .altsetting_count = 1,
    .altsettings =
    {
        &usb_c1_i0_a0,
    },
};

static const struct usb_altsetting usb_simpledebug_intf_a0 =
{
    .set_altsetting = usbdebug_enable,
    .unset_altsetting = usbdebug_disable,
    .endpoint_count = 0,
    .endpoints =
    {
    },
};

static struct usb_interface usb_simpledebug_intf =
{
    .bus_reset = NULL,
    .ctrl_request = usbdebug_handle_setup,
    .altsetting_count = 1,
    .altsettings =
    {
        &usb_simpledebug_intf_a0,
    },
};

static const struct usb_configuration usb_c1 =
{
    .descriptor = &usb_config1_descriptors.c1,
    .set_configuration = NULL,
    .unset_configuration = NULL,
    .interface_count = 1,
    .interfaces =
    {
        &usb_c1_i0,
    },
};


static USB_DRIVER_CONFIG_TYPE usb_driver_config = USB_DRIVER_CONFIG;

static USB_DRIVER_STATE_TYPE usb_driver_state = USB_DRIVER_STATE;

static struct usb_state usb_state =
{
    .interface_altsetting = { 0 },
};

static union usb_ep0_buffer usb_buffer CACHEALIGN_ATTR;

struct usb_instance usb_default_data =
{
    .driver = &USB_DRIVER,
    .driver_config = &usb_driver_config,
    .driver_state = &usb_driver_state,
    .state = &usb_state,
    .buffer = &usb_buffer,
    .bus_reset = usbglue_bus_reset,
    .ep0_setup_hook = NULL,
    .configuration_count = 1,
    .stringdescriptor_count = 3,
    .devicedescriptor = &usb_devicedescriptor,
    .stringdescriptors = usb_stringdescriptors,
    .configurations =
    {
        &usb_c1,
    },
};

struct usb_instance* usb_data = &usb_default_data;

static struct scheduler_thread usbmanager_thread_handle;
static uint32_t usbmanager_stack[0x40] STACK_ATTR;
static bool usb_connected;
static struct mutex usbmanager_mutex;

void usbmanager_thread(void* arg0, void* arg1, void* arg2, void* arg3)
{
    while (true)
    {
        sleep(200000);
        mutex_lock(&usbmanager_mutex, TIMEOUT_BLOCK);
        bool newstate = vbus_state();
        if (usb_connected != newstate)
        {
            if (newstate) usb_init(usb_data);
            else usb_exit(usb_data);
            usb_connected = newstate;
        }
        mutex_unlock(&usbmanager_mutex);
    }
}

void usbmanager_init()
{
    mutex_init(&usbmanager_mutex);
    usb_connected = false;
    usbdebug_init();
    
    thread_create(&usbmanager_thread_handle, "synopsysotg", usbmanager_thread,
                  usbmanager_stack, sizeof(usbmanager_stack), OS_THREAD, 63, true,
                  NULL, NULL, NULL, NULL);
}

void usbmanager_exit()
{
    if (usb_connected) usb_exit(usb_data);
}

int usbmanager_install_custom(const struct usb_devicedescriptor* devicedescriptor,
                              uint8_t config_count, const struct usb_configuration** configurations,
                              uint8_t string_count, const struct usb_stringdescriptor** stringdescriptors,
                              bool enable_debug)
{
    int i, j, k, l;
    int size = sizeof(struct usb_instance);
    int descsize = sizeof(struct usb_devicedescriptor);
    int max_interfaces = 0;
    for (i = 0; i < config_count; i++)
    {
        const struct usb_configuration* configuration = configurations[i];
        size += 4 + sizeof(struct usb_configuration);
        descsize += configuration->descriptor->wTotalLength;
        if (configuration->interface_count > max_interfaces)
            max_interfaces = configuration->interface_count;
        for (j = 0; j < configuration->interface_count; j++)
        {
            const struct usb_interface* interface = configuration->interfaces[j];
            size += 4 + sizeof(struct usb_interface);
            for (k = 0; k < interface->altsetting_count; k++)
            {
                const struct usb_altsetting* altsetting = interface->altsettings[k];
                size += 4 + sizeof(struct usb_altsetting)
                      + (4 + sizeof(struct usb_endpoint)) * altsetting->endpoint_count;
            }
        }
    }
    for (i = 0; i < string_count; i++) descsize += stringdescriptors[i]->bLength;
    if (enable_debug)
    {
        size += 4;
        descsize += sizeof(struct usb_interfacedescriptor);
        if (configurations[0]->interface_count == max_interfaces) max_interfaces++;
    }
    size += 4 * string_count + sizeof(struct usb_state) + max_interfaces;
    void* buf = malloc(size + descsize);
    if (!buf) RET_ERR(1);
    reownalloc(buf, KERNEL_OWNER(KERNEL_OWNER_CUSTOM_USB));
    void* descbuf = buf + size;
    struct usb_instance* instance = (struct usb_instance*)buf;
    buf += sizeof(struct usb_instance) + 4 * config_count;
    memcpy(instance, &usb_default_data, sizeof(struct usb_instance));
    struct usb_devicedescriptor* devdescriptor = (struct usb_devicedescriptor*)descbuf;
    descbuf += sizeof(struct usb_devicedescriptor);
    memcpy(devdescriptor, devicedescriptor, sizeof(struct usb_devicedescriptor));
    instance->devicedescriptor = devdescriptor;
    for (i = 0; i < config_count; i++)
    {
        const struct usb_configuration* configuration = configurations[i];
        struct usb_configuration* config = (struct usb_configuration*)buf;
        buf += sizeof(struct usb_configuration) + 4 * configuration->interface_count;
        memcpy(config, configuration, sizeof(struct usb_configuration));
        instance->configurations[i] = config;
        struct usb_configurationdescriptor* cfgdescriptor = (struct usb_configurationdescriptor*)descbuf;
        descbuf += configuration->descriptor->wTotalLength;
        memcpy(cfgdescriptor, configuration->descriptor, configuration->descriptor->wTotalLength);
        config->descriptor = cfgdescriptor;
        if (!i && enable_debug) buf += 4;
        for (j = 0; j < configuration->interface_count; j++)
        {
            const struct usb_interface* interface = configuration->interfaces[j];
            struct usb_interface* intf = (struct usb_interface*)buf;
            buf += sizeof(struct usb_interface) + 4 * interface->altsetting_count;
            memcpy(intf, interface, sizeof(struct usb_interface));
            config->interfaces[j] = intf;
            for (k = 0; k < interface->altsetting_count; k++)
            {
                const struct usb_altsetting* altsetting = interface->altsettings[k];
                struct usb_altsetting* as = (struct usb_altsetting*)buf;
                buf += sizeof(struct usb_altsetting) + 4 * altsetting->endpoint_count;
                memcpy(as, altsetting, sizeof(struct usb_altsetting));
                intf->altsettings[k] = as;
                for (l = 0; l < altsetting->endpoint_count; l++)
                {
                    const struct usb_endpoint* endpoint = altsetting->endpoints[l];
                    struct usb_endpoint* ep = (struct usb_endpoint*)buf;
                    buf += sizeof(struct usb_endpoint);
                    memcpy(ep, endpoint, sizeof(struct usb_endpoint));
                    as->endpoints[l] = ep;
                }
            }
        }
        if (!i && enable_debug)
        {
            struct usb_interfacedescriptor* intfdescriptor = (struct usb_interfacedescriptor*)descbuf;
            descbuf += sizeof(struct usb_interfacedescriptor);
            memcpy(intfdescriptor, &usb_simpledebug_intf_desc, sizeof(struct usb_interfacedescriptor));
            intfdescriptor->bInterfaceNumber = j;
            config->interfaces[j] = &usb_simpledebug_intf;
            config->interface_count++;
            cfgdescriptor->wTotalLength += sizeof(struct usb_interfacedescriptor);
            cfgdescriptor->bNumInterfaces++;
        }
    }
    const struct usb_stringdescriptor** stringdescs = (const struct usb_stringdescriptor**)buf;
    buf += 4 * string_count;
    instance->stringdescriptors = stringdescs;
    for (i = 0; i < string_count; i++)
    {
        const struct usb_stringdescriptor* stringdescriptor = stringdescriptors[i];
        struct usb_stringdescriptor* stringdesc = (struct usb_stringdescriptor*)descbuf;
        descbuf += stringdescriptor->bLength;
        memcpy(stringdesc, stringdescriptor, stringdescriptor->bLength);
        stringdescs[i] = stringdesc;
    }
    struct usb_state* state = (struct usb_state*)buf;
    buf += sizeof(struct usb_state) + max_interfaces;
    instance->state = state;
    mutex_lock(&usbmanager_mutex, TIMEOUT_BLOCK);
    if (usb_connected) usb_exit(usb_data);
    if (usb_data != &usb_default_data) free(usb_data);
    usb_data = instance;
    if (usb_connected) usb_init(usb_data);
    mutex_unlock(&usbmanager_mutex);
    return 0;
}

void usbmanager_uninstall_custom()
{
    mutex_lock(&usbmanager_mutex, TIMEOUT_BLOCK);
    if (usb_data != &usb_default_data)
    {
        if (usb_connected) usb_exit(usb_data);
        free(usb_data);
        usb_data = &usb_default_data;
        if (usb_connected) usb_init(usb_data);
    }
    mutex_unlock(&usbmanager_mutex);
}

uint32_t usbmanager_get_available_endpoints()
{
    return USB_ENDPOINTS;
}

bool usbmanager_get_connected()
{
    return usb_connected;
}