source: mainline/uspace/lib/usbdev/src/driver.c@ 6ff23ff

/*
 * Copyright (c) 2011 Vojtech Horky
 * Copyright (c) 2013 Jan Vesely
 * Copyright (c) 2018 Petr Manek
 * 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 libusbdev
 * @{
 */
/** @file
 * USB device driver framework.
 */

#include <usb/dev/driver.h>
#include <usb/dev/device.h>
#include <usb/debug.h>

#include <assert.h>
#include <errno.h>
#include <str_error.h>
#include <ddf/driver.h>

static const usb_driver_t *driver = NULL;

/** Callback when a new device is supposed to be controlled by this driver.
 *
 * This callback is a wrapper for USB specific version of @c device_add.
 *
 * @param gen_dev Device structure as prepared by DDF.
 * @return Error code.
 */
static errno_t generic_device_add(ddf_dev_t *gen_dev)
{
        assert(driver);
        assert(driver->ops);
        assert(driver->ops->device_add);

        /* Initialize generic USB driver data. */
        const char *err_msg = NULL;
        errno_t rc = usb_device_create_ddf(gen_dev, driver->endpoints, &err_msg);
        if (rc != EOK) {
                usb_log_error("USB device `%s' init failed (%s): %s.",
                    ddf_dev_get_name(gen_dev), err_msg, str_error(rc));
                return rc;
        }

        /* Start USB driver specific initialization. */
        rc = driver->ops->device_add(ddf_dev_data_get(gen_dev));
        if (rc != EOK)
                usb_device_destroy_ddf(gen_dev);
        return rc;
}

/** Callback when a device is supposed to be removed from the system.
 *
 * This callback is a wrapper for USB specific version of @c device_remove.
 *
 * @param gen_dev Device structure as prepared by DDF.
 * @return Error code.
 */
static errno_t generic_device_remove(ddf_dev_t *gen_dev)
{
        assert(driver);
        assert(driver->ops);
        if (driver->ops->device_remove == NULL)
                return ENOTSUP;

        /* Just tell the driver to stop whatever it is doing */
        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
        const errno_t ret = driver->ops->device_remove(usb_dev);
        if (ret != EOK)
                return ret;

        usb_device_destroy_ddf(gen_dev);
        return EOK;
}

/** Callback when a device was removed from the system.
 *
 * This callback is a wrapper for USB specific version of @c device_gone.
 *
 * @param gen_dev Device structure as prepared by DDF.
 * @return Error code.
 */
static errno_t generic_device_gone(ddf_dev_t *gen_dev)
{
        assert(driver);
        assert(driver->ops);
        if (driver->ops->device_gone == NULL)
                return ENOTSUP;
        usb_device_t *usb_dev = ddf_dev_data_get(gen_dev);
        const errno_t ret = driver->ops->device_gone(usb_dev);
        if (ret == EOK)
                usb_device_destroy_ddf(gen_dev);

        return ret;
}

/** Callback when the driver is asked to online a specific function.
 *
 * This callback is a wrapper for USB specific version of @c fun_online.
 *
 * @param gen_dev Device function structure as prepared by DDF.
 * @return Error code.
 */
static int generic_function_online(ddf_fun_t *fun)
{
        assert(driver);
        assert(driver->ops);
        if (driver->ops->function_online == NULL)
                return ENOTSUP;
        return driver->ops->function_online(fun);
}

/** Callback when the driver is asked to offline a specific function.
 *
 * This callback is a wrapper for USB specific version of @c fun_offline.
 *
 * @param gen_dev Device function structure as prepared by DDF.
 * @return Error code.
 */
static int generic_function_offline(ddf_fun_t *fun)
{
        assert(driver);
        assert(driver->ops);
        if (driver->ops->function_offline == NULL)
                return ENOTSUP;
        return driver->ops->function_offline(fun);
}

static driver_ops_t generic_driver_ops = {
        .dev_add = generic_device_add,
        .dev_remove = generic_device_remove,
        .dev_gone = generic_device_gone,
        .fun_online = generic_function_online,
        .fun_offline = generic_function_offline,
};
static driver_t generic_driver = {
        .driver_ops = &generic_driver_ops
};


/** Main routine of USB device driver.
 *
 * Under normal conditions, this function never returns.
 *
 * @param drv USB device driver structure.
 * @return Task exit status.
 */
int usb_driver_main(const usb_driver_t *drv)
{
        assert(drv != NULL);

        /* Prepare the generic driver. */
        generic_driver.name = drv->name;

        driver = drv;

        return ddf_driver_main(&generic_driver);
}

/**
 * @}
 */