src/usb.c

// Main code for handling USB controllers and devices.
//
// Copyright (C) 2009  Kevin O'Connor <kevin@koconnor.net>
//
// This file may be distributed under the terms of the GNU LGPLv3 license.

#include "util.h" // dprintf
#include "pci.h" // foreachpci
#include "config.h" // CONFIG_*
#include "pci_regs.h" // PCI_CLASS_REVISION
#include "pci_ids.h" // PCI_CLASS_SERIAL_USB_UHCI
#include "usb-uhci.h" // uhci_init
#include "usb-ohci.h" // ohci_init
#include "usb-ehci.h" // ehci_init
#include "usb-hid.h" // usb_keyboard_setup
#include "usb-hub.h" // usb_hub_init
#include "usb-msc.h" // usb_msc_init
#include "usb.h" // struct usb_s
#include "biosvar.h" // GET_GLOBAL


/****************************************************************
 * Controller function wrappers
 ****************************************************************/

// Free an allocated control or bulk pipe.
void
free_pipe(struct usb_pipe *pipe)
{
    ASSERT32FLAT();
    if (!pipe)
        return;
    // Add to controller's free list.
    struct usb_s *cntl = pipe->cntl;
    pipe->freenext = cntl->freelist;
    cntl->freelist = pipe;
}

// Allocate an async pipe (control or bulk).
static struct usb_pipe *
alloc_async_pipe(struct usb_pipe *dummy)
{
    // Check for an available pipe on the freelist.
    struct usb_pipe **pfree = &dummy->cntl->freelist;
    for (;;) {
        struct usb_pipe *pipe = *pfree;
        if (!pipe)
            break;
        if (pipe->eptype == dummy->eptype) {
            // Use previously allocated pipe.
            *pfree = pipe->freenext;
            memcpy(pipe, dummy, sizeof(*pipe));
            return pipe;
        }
        pfree = &pipe->freenext;
    }

    // Allocate a new pipe.
    switch (dummy->type) {
    default:
    case USB_TYPE_UHCI:
        return uhci_alloc_async_pipe(dummy);
    case USB_TYPE_OHCI:
        return ohci_alloc_async_pipe(dummy);
    case USB_TYPE_EHCI:
        return ehci_alloc_async_pipe(dummy);
    }
}

// Send a message on a control pipe using the default control descriptor.
static int
send_control(struct usb_pipe *pipe, int dir, const void *cmd, int cmdsize
             , void *data, int datasize)
{
    ASSERT32FLAT();
    switch (pipe->type) {
    default:
    case USB_TYPE_UHCI:
        return uhci_control(pipe, dir, cmd, cmdsize, data, datasize);
    case USB_TYPE_OHCI:
        return ohci_control(pipe, dir, cmd, cmdsize, data, datasize);
    case USB_TYPE_EHCI:
        return ehci_control(pipe, dir, cmd, cmdsize, data, datasize);
    }
}

// Fill "pipe" endpoint info from an endpoint descriptor.
static void
desc2pipe(struct usb_pipe *newpipe, struct usb_pipe *origpipe
          , struct usb_endpoint_descriptor *epdesc)
{
    memcpy(newpipe, origpipe, sizeof(*newpipe));
    newpipe->ep = epdesc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
    newpipe->maxpacket = epdesc->wMaxPacketSize;
}

struct usb_pipe *
alloc_bulk_pipe(struct usb_pipe *pipe, struct usb_endpoint_descriptor *epdesc)
{
    struct usb_pipe dummy;
    desc2pipe(&dummy, pipe, epdesc);
    dummy.eptype = USB_ENDPOINT_XFER_BULK;
    return alloc_async_pipe(&dummy);
}

int
usb_send_bulk(struct usb_pipe *pipe_fl, int dir, void *data, int datasize)
{
    switch (GET_FLATPTR(pipe_fl->type)) {
    default:
    case USB_TYPE_UHCI:
        return uhci_send_bulk(pipe_fl, dir, data, datasize);
    case USB_TYPE_OHCI:
        return ohci_send_bulk(pipe_fl, dir, data, datasize);
    case USB_TYPE_EHCI:
        return ehci_send_bulk(pipe_fl, dir, data, datasize);
    }
}

struct usb_pipe *
alloc_intr_pipe(struct usb_pipe *pipe, struct usb_endpoint_descriptor *epdesc)
{
    struct usb_pipe dummy;
    desc2pipe(&dummy, pipe, epdesc);
    // Find the exponential period of the requested time.
    int period = epdesc->bInterval;
    int frameexp;
    if (pipe->speed != USB_HIGHSPEED)
        frameexp = (period <= 0) ? 0 : __fls(period);
    else
        frameexp = (period <= 4) ? 0 : period - 4;
    switch (pipe->type) {
    default:
    case USB_TYPE_UHCI:
        return uhci_alloc_intr_pipe(&dummy, frameexp);
    case USB_TYPE_OHCI:
        return ohci_alloc_intr_pipe(&dummy, frameexp);
    case USB_TYPE_EHCI:
        return ehci_alloc_intr_pipe(&dummy, frameexp);
    }
}

int noinline
usb_poll_intr(struct usb_pipe *pipe_fl, void *data)
{
    switch (GET_FLATPTR(pipe_fl->type)) {
    default:
    case USB_TYPE_UHCI:
        return uhci_poll_intr(pipe_fl, data);
    case USB_TYPE_OHCI:
        return ohci_poll_intr(pipe_fl, data);
    case USB_TYPE_EHCI:
        return ehci_poll_intr(pipe_fl, data);
    }
}


/****************************************************************
 * Helper functions
 ****************************************************************/

// Find the first endpoing of a given type in an interface description.
struct usb_endpoint_descriptor *
findEndPointDesc(struct usb_interface_descriptor *iface, int imax
                 , int type, int dir)
{
    struct usb_endpoint_descriptor *epdesc = (void*)&iface[1];
    for (;;) {
        if ((void*)epdesc >= (void*)iface + imax
            || epdesc->bDescriptorType == USB_DT_INTERFACE) {
            return NULL;
        }
        if (epdesc->bDescriptorType == USB_DT_ENDPOINT
            && (epdesc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir
            && (epdesc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == type)
            return epdesc;
        epdesc = (void*)epdesc + epdesc->bLength;
    }
}

// Send a message to the default control pipe of a device.
int
send_default_control(struct usb_pipe *pipe, const struct usb_ctrlrequest *req
                     , void *data)
{
    return send_control(pipe, req->bRequestType & USB_DIR_IN
                        , req, sizeof(*req), data, req->wLength);
}

// Get the first 8 bytes of the device descriptor.
static int
get_device_info8(struct usb_pipe *pipe, struct usb_device_descriptor *dinfo)
{
    struct usb_ctrlrequest req;
    req.bRequestType = USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
    req.bRequest = USB_REQ_GET_DESCRIPTOR;
    req.wValue = USB_DT_DEVICE<<8;
    req.wIndex = 0;
    req.wLength = 8;
    return send_default_control(pipe, &req, dinfo);
}

static struct usb_config_descriptor *
get_device_config(struct usb_pipe *pipe)
{
    struct usb_config_descriptor cfg;

    struct usb_ctrlrequest req;
    req.bRequestType = USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
    req.bRequest = USB_REQ_GET_DESCRIPTOR;
    req.wValue = USB_DT_CONFIG<<8;
    req.wIndex = 0;
    req.wLength = sizeof(cfg);
    int ret = send_default_control(pipe, &req, &cfg);
    if (ret)
        return NULL;

    void *config = malloc_tmphigh(cfg.wTotalLength);
    if (!config)
        return NULL;
    req.wLength = cfg.wTotalLength;
    ret = send_default_control(pipe, &req, config);
    if (ret)
        return NULL;
    //hexdump(config, cfg.wTotalLength);
    return config;
}

static int
set_configuration(struct usb_pipe *pipe, u16 val)
{
    struct usb_ctrlrequest req;
    req.bRequestType = USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
    req.bRequest = USB_REQ_SET_CONFIGURATION;
    req.wValue = val;
    req.wIndex = 0;
    req.wLength = 0;
    return send_default_control(pipe, &req, NULL);
}


/****************************************************************
 * Initialization and enumeration
 ****************************************************************/

// Assign an address to a device in the default state on the given
// controller.
static int
usb_set_address(struct usbdevice_s *usbdev)
{
    ASSERT32FLAT();
    struct usbhub_s *hub = usbdev->hub;
    struct usb_s *cntl = hub->cntl;
    dprintf(3, "set_address %p\n", cntl);
    if (cntl->maxaddr >= USB_MAXADDR)
        return -1;

    // Create a pipe for the default address.
    struct usb_pipe dummy;
    memset(&dummy, 0, sizeof(dummy));
    dummy.cntl = cntl;
    dummy.type = cntl->type;
    dummy.maxpacket = 8;
    dummy.path = (u64)-1;
    dummy.eptype = USB_ENDPOINT_XFER_CONTROL;
    struct usb_pipe *defpipe = alloc_async_pipe(&dummy);
    if (!defpipe)
        return -1;
    usbdev->defpipe = defpipe;
    defpipe->speed = usbdev->speed;
    if (hub->pipe) {
        if (hub->pipe->speed == USB_HIGHSPEED) {
            defpipe->tt_devaddr = hub->pipe->devaddr;
            defpipe->tt_port = usbdev->port;
        } else {
            defpipe->tt_devaddr = hub->pipe->tt_devaddr;
            defpipe->tt_port = hub->pipe->tt_port;
        }
    } else {
        defpipe->tt_devaddr = defpipe->tt_port = 0;
    }
    if (hub->pipe)
        defpipe->path = hub->pipe->path;
    defpipe->path = (defpipe->path << 8) | usbdev->port;

    msleep(USB_TIME_RSTRCY);

    struct usb_ctrlrequest req;
    req.bRequestType = USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
    req.bRequest = USB_REQ_SET_ADDRESS;
    req.wValue = cntl->maxaddr + 1;
    req.wIndex = 0;
    req.wLength = 0;
    int ret = send_default_control(defpipe, &req, NULL);
    if (ret) {
        free_pipe(defpipe);
        return -1;
    }

    msleep(USB_TIME_SETADDR_RECOVERY);

    cntl->maxaddr++;
    defpipe->devaddr = cntl->maxaddr;
    return 0;
}

// Called for every found device - see if a driver is available for
// this device and do setup if so.
static int
configure_usb_device(struct usbdevice_s *usbdev)
{
    ASSERT32FLAT();
    struct usb_pipe *pipe = usbdev->defpipe;
    dprintf(3, "config_usb: %p\n", pipe);

    // Set the max packet size for endpoint 0 of this device.
    struct usb_device_descriptor dinfo;
    int ret = get_device_info8(pipe, &dinfo);
    if (ret)
        return 0;
    dprintf(3, "device rev=%04x cls=%02x sub=%02x proto=%02x size=%02x\n"
            , dinfo.bcdUSB, dinfo.bDeviceClass, dinfo.bDeviceSubClass
            , dinfo.bDeviceProtocol, dinfo.bMaxPacketSize0);
    if (dinfo.bMaxPacketSize0 < 8 || dinfo.bMaxPacketSize0 > 64)
        return 0;
    pipe->maxpacket = dinfo.bMaxPacketSize0;

    // Get configuration
    struct usb_config_descriptor *config = get_device_config(pipe);
    if (!config)
        return 0;

    // Determine if a driver exists for this device - only look at the
    // first interface of the first configuration.
    struct usb_interface_descriptor *iface = (void*)(&config[1]);
    if (iface->bInterfaceClass != USB_CLASS_HID
        && iface->bInterfaceClass != USB_CLASS_MASS_STORAGE
        && iface->bInterfaceClass != USB_CLASS_HUB)
        // Not a supported device.
        goto fail;

    // Set the configuration.
    ret = set_configuration(pipe, config->bConfigurationValue);
    if (ret)
        goto fail;

    // Configure driver.
    int imax = (void*)config + config->wTotalLength - (void*)iface;
    if (iface->bInterfaceClass == USB_CLASS_HUB)
        ret = usb_hub_init(pipe);
    else if (iface->bInterfaceClass == USB_CLASS_MASS_STORAGE)
        ret = usb_msc_init(pipe, iface, imax);
    else
        ret = usb_hid_init(pipe, iface, imax);
    if (ret)
        goto fail;

    free(config);
    return 1;
fail:
    free(config);
    return 0;
}

static void
usb_init_hub_port(void *data)
{
    struct usbdevice_s *usbdev = data;
    struct usbhub_s *hub = usbdev->hub;
    u32 port = usbdev->port;

    // Detect if device present (and possibly start reset)
    int ret = hub->op->detect(hub, port);
    if (ret)
        // No device present
        goto done;

    // Reset port and determine device speed
    mutex_lock(&hub->cntl->resetlock);
    ret = hub->op->reset(hub, port);
    if (ret < 0)
        // Reset failed
        goto resetfail;
    usbdev->speed = ret;

    // Set address of port
    ret = usb_set_address(usbdev);
    if (ret) {
        hub->op->disconnect(hub, port);
        goto resetfail;
    }
    mutex_unlock(&hub->cntl->resetlock);

    // Configure the device
    int count = configure_usb_device(usbdev);
    free_pipe(usbdev->defpipe);
    if (!count)
        hub->op->disconnect(hub, port);
    hub->devcount += count;
done:
    hub->threads--;
    free(usbdev);
    return;

resetfail:
    mutex_unlock(&hub->cntl->resetlock);
    goto done;
}

void
usb_enumerate(struct usbhub_s *hub)
{
    u32 portcount = hub->portcount;
    hub->threads = portcount;

    // Launch a thread for every port.
    int i;
    for (i=0; i<portcount; i++) {
        struct usbdevice_s *usbdev = malloc_tmphigh(sizeof(*usbdev));
        if (!usbdev) {
            warn_noalloc();
            continue;
        }
        memset(usbdev, 0, sizeof(*usbdev));
        usbdev->hub = hub;
        usbdev->port = i;
        run_thread(usb_init_hub_port, usbdev);
    }

    // Wait for threads to complete.
    while (hub->threads)
        yield();
}

void
usb_setup(void)
{
    ASSERT32FLAT();
    if (! CONFIG_USB)
        return;

    dprintf(3, "init usb\n");

    // Look for USB controllers
    int count = 0;
    struct pci_device *ehcipci = PCIDevices;
    struct pci_device *pci;
    foreachpci(pci) {
        if (pci->class != PCI_CLASS_SERIAL_USB)
            continue;

        if (pci->bdf >= ehcipci->bdf) {
            // Check to see if this device has an ehci controller
            int found = 0;
            ehcipci = pci;
            for (;;) {
                if (pci_classprog(ehcipci) == PCI_CLASS_SERIAL_USB_EHCI) {
                    // Found an ehci controller.
                    int ret = ehci_init(ehcipci, count++, pci);
                    if (ret)
                        // Error
                        break;
                    count += found;
                    pci = ehcipci;
                    break;
                }
                if (ehcipci->class == PCI_CLASS_SERIAL_USB)
                    found++;
                ehcipci = ehcipci->next;
                if (!ehcipci || (pci_bdf_to_busdev(ehcipci->bdf)
                                 != pci_bdf_to_busdev(pci->bdf)))
                    // No ehci controller found.
                    break;
            }
        }

        if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_UHCI)
            uhci_init(pci, count++);
        else if (pci_classprog(pci) == PCI_CLASS_SERIAL_USB_OHCI)
            ohci_init(pci, count++);
    }
}