source: mainline/uspace/lib/usb/src/hcdhubd.c@ 4b4c797

/*
 * Copyright (c) 2010 Vojtech Horky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libusb usb
 * @{
 */
/** @file
 * @brief HC driver and hub driver (implementation).
 */
#include <usb/hcdhubd.h>
#include <usb_iface.h>
#include <driver.h>
#include <bool.h>
#include <errno.h>

/** List of handled host controllers. */
static LIST_INITIALIZE(hc_list);

/** Our HC driver. */
static usb_hc_driver_t *hc_driver = NULL;

static usb_iface_t usb_interface = {
        .interrupt_out = NULL,
        .interrupt_in = NULL
};

static device_ops_t usb_device_ops = {
        .interfaces[USB_DEV_IFACE] = &usb_interface
};

/** Callback when new device is detected and must be handled by this driver.
 *
 * @param dev New device.
 * @return Error code.
 */
static int add_device(device_t *dev)
{
        /*
         * FIXME: use some magic to determine whether hub or another HC
         * was connected.
         */
        bool is_hc = true;

        if (is_hc) {
                /*
                 * We are the HC itself.
                 */
                usb_hc_device_t *hc_dev = malloc(sizeof(usb_hc_device_t));
                list_initialize(&hc_dev->link);
                hc_dev->transfer_ops = NULL;

                hc_dev->generic = dev;
                dev->ops = &usb_device_ops;
                hc_dev->generic->driver_data = hc_dev;

                int rc = hc_driver->add_hc(hc_dev);
                if (rc != EOK) {
                        free(hc_dev);
                        return rc;
                }

                /*
                 * FIXME: The following line causes devman to hang.
                 * Will investigate later why.
                 */
                // add_device_to_class(dev, "usbhc");

                list_append(&hc_dev->link, &hc_list);

                return EOK;
        } else {
                /*
                 * We are some (probably deeply nested) hub.
                 * Thus, assign our own operations and explore already
                 * connected devices.
                 */
                return ENOTSUP;
        }
}

/** Check changes on all known hubs.
 */
static void check_hub_changes(void)
{
        /*
         * Iterate through all HCs.
         */
        link_t *link_hc;
        for (link_hc = hc_list.next;
            link_hc != &hc_list;
            link_hc = link_hc->next) {
                usb_hc_device_t *hc = list_get_instance(link_hc,
                    usb_hc_device_t, link);
                /*
                 * Iterate through all their hubs.
                 */
                link_t *link_hub;
                for (link_hub = hc->hubs.next;
                    link_hub != &hc->hubs;
                    link_hub = link_hub->next) {
                        usb_hcd_hub_info_t *hub = list_get_instance(link_hub,
                            usb_hcd_hub_info_t, link);

                        /*
                         * Check status change pipe of this hub.
                         */
                        usb_target_t target = {
                                .address = hub->device->address,
                                .endpoint = 1
                        };

                        // FIXME: count properly
                        size_t byte_length = (hub->port_count / 8) + 1;

                        void *change_bitmap = malloc(byte_length);
                        size_t actual_size;
                        usb_handle_t handle;

                        /*
                         * Send the request.
                         * FIXME: check returned value for possible errors
                         */
                        usb_hc_async_interrupt_in(hc, target,
                            change_bitmap, byte_length, &actual_size,
                            &handle);

                        usb_hc_async_wait_for(handle);

                        /*
                         * TODO: handle the changes.
                         */
                }
        }
}

/** Operations for combined HC and HUB driver. */
static driver_ops_t hc_driver_generic_ops = {
        .add_device = add_device
};

/** Combined HC and HUB driver. */
static driver_t hc_driver_generic = {
        .driver_ops = &hc_driver_generic_ops
};

/** Main USB host controller driver routine.
 *
 * @see driver_main
 *
 * @param hc Host controller driver.
 * @return Error code.
 */
int usb_hcd_main(usb_hc_driver_t *hc)
{
        hc_driver = hc;
        hc_driver_generic.name = hc->name;

        /*
         * Launch here fibril that will periodically check all
         * attached hubs for status change.
         * WARN: This call will effectively do nothing.
         */
        check_hub_changes();

        /*
         * Run the device driver framework.
         */
        return driver_main(&hc_driver_generic);
}

/** Add a root hub for given host controller.
 * This function shall be called only once for each host controller driven
 * by this driver.
 * It takes care of creating child device - hub - that will be driven by
 * this task.
 *
 * @param dev Host controller device.
 * @return Error code.
 */
int usb_hcd_add_root_hub(usb_hc_device_t *dev)
{
        int rc;

        /*
         * For testing/debugging purposes only.
         * Try to send some data to default USB address.
         */
        usb_target_t target = {0, 0};
        usb_handle_t handle = 0;
        char *data = (char *) "Hello, World!";


        (void)usb_hc_async_interrupt_out(dev, target, data, str_length(data), &handle);
        (void)usb_hc_async_wait_for(handle);

        /*
         * Announce presence of child device.
         */
        device_t *hub = NULL;
        match_id_t *match_id = NULL;

        hub = create_device();
        if (hub == NULL) {
                rc = ENOMEM;
                goto failure;
        }
        hub->name = "usbhub";

        match_id = create_match_id();
        if (match_id == NULL) {
                rc = ENOMEM;
                goto failure;
        }

        char *id;
        rc = asprintf(&id, "usb&hc=%s&hub", dev->generic->name);
        if (rc <= 0) {
                rc = ENOMEM;
                goto failure;
        }

        match_id->id = id;
        match_id->score = 30;

        add_match_id(&hub->match_ids, match_id);

        rc = child_device_register(hub, dev->generic);
        if (rc != EOK) {
                goto failure;
        }

        printf("%s: registered root hub\n", dev->generic->name);
        return EOK;

failure:
        if (hub != NULL) {
                hub->name = NULL;
                delete_device(hub);
        }
        delete_match_id(match_id);

        return rc;
}

/** Issue interrupt OUT transfer to HC driven by current task.
 *
 * @param hc Host controller to handle the transfer.
 * @param target Target device address.
 * @param buffer Data buffer.
 * @param size Buffer size.
 * @param handle Transfer handle.
 * @return Error code.
 */
int usb_hc_async_interrupt_out(usb_hc_device_t *hc, usb_target_t target,
    void *buffer, size_t size,
    usb_handle_t *handle)
{
        if ((hc->transfer_ops == NULL)
            || (hc->transfer_ops->transfer_out == NULL)) {
                return ENOTSUP;
        }

        /*
         * For debugging purposes only.
         * We need to find appropriate device in list of managed device
         * and pass it to the transfer callback function.
         */
        usb_hcd_attached_device_info_t dev = {
                .address = target.address,
                .endpoint_count = 0,
                .endpoints = NULL,
        };
        usb_hc_endpoint_info_t endpoint = {
                .endpoint = target.endpoint,
                .transfer_type = USB_TRANSFER_INTERRUPT,
                .direction = USB_DIRECTION_OUT,
                .data_toggle = 0
        };

        hc->transfer_ops->transfer_out(hc, &dev, &endpoint, buffer, size, NULL, NULL);

        *handle = NULL;

        return EOK;
}


/** Issue interrupt IN transfer to HC driven by current task.
 *
 * @warning The @p buffer and @p actual_size parameters shall not be
 * touched until this transfer is waited for by usb_hc_async_wait_for().
 *
 * @param hc Host controller to handle the transfer.
 * @param target Target device address.
 * @param buffer Data buffer.
 * @param size Buffer size.
 * @param actual_size Size of actually transferred data.
 * @param handle Transfer handle.
 * @return Error code.
 */
int usb_hc_async_interrupt_in(usb_hc_device_t *hc, usb_target_t target,
    void *buffer, size_t size, size_t *actual_size,
    usb_handle_t *handle)
{
        /*
         * TODO: verify that given endpoint is of interrupt type and
         * call hc->transfer_ops->transfer_in()
         */
        return ENOTSUP;
}

/** Wait for transfer to complete.
 *
 * @param handle Transfer handle.
 * @return Error code.
 */
int usb_hc_async_wait_for(usb_handle_t handle)
{
        return ENOTSUP;
}

/**
 * @}
 */