/*-
 * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
 * Copyright (c) 2018 Andrew Turner <andrew@FreeBSD.org>
 * All rights reserved.
 *
 * This software was developed by SRI International and the University of
 * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237
 * ("CTSRD"), as part of the DARPA CRASH research programme.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * 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.
 */

/*
 * Allwinner USB Dual-Role Device (DRD) controller
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/rman.h>
#include <sys/kernel.h>
#include <sys/condvar.h>
#include <sys/module.h>

#include <machine/bus.h>

#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>

#include <dev/usb/usb_core.h>
#include <dev/usb/usb_busdma.h>
#include <dev/usb/usb_process.h>
#include <dev/usb/usb_util.h>

#include <dev/usb/usb_controller.h>
#include <dev/usb/usb_bus.h>
#include <dev/usb/controller/musb_otg.h>

#include <dev/clk/clk.h>
#include <dev/hwreset/hwreset.h>
#include <dev/phy/phy.h>
#include <dev/phy/phy_usb.h>

#ifdef __arm__
#include <arm/allwinner/aw_machdep.h>
#include <arm/allwinner/a10_sramc.h>
#endif

#define DRD_EP_MAX              5
#define DRD_EP_MAX_H3           4

#define MUSB2_REG_AWIN_VEND0    0x0043
#define VEND0_PIO_MODE          0

#if defined(__arm__)
#define bs_parent_space(bs)     ((bs)->bs_parent)
typedef bus_space_tag_t awusb_bs_tag;
#elif defined(__aarch64__) || defined(__riscv)
#define bs_parent_space(bs)     (bs)
typedef void *          awusb_bs_tag;
#endif

#define AWUSB_OKAY              0x01
#define AWUSB_NO_CONFDATA       0x02
static struct ofw_compat_data compat_data[] = {
        { "allwinner,sun4i-a10-musb",   AWUSB_OKAY },
        { "allwinner,sun6i-a31-musb",   AWUSB_OKAY },
        { "allwinner,sun8i-a33-musb",   AWUSB_OKAY | AWUSB_NO_CONFDATA },
        { "allwinner,sun8i-h3-musb",    AWUSB_OKAY | AWUSB_NO_CONFDATA },
        { "allwinner,sun20i-d1-musb",   AWUSB_OKAY | AWUSB_NO_CONFDATA },
        { NULL,                         0 }
};

static const struct musb_otg_ep_cfg musbotg_ep_allwinner[] = {
        {
                .ep_end = DRD_EP_MAX,
                .ep_fifosz_shift = 9,
                .ep_fifosz_reg = MUSB2_VAL_FIFOSZ_512,
        },
        {
                .ep_end = -1,
        },
};

static const struct musb_otg_ep_cfg musbotg_ep_allwinner_h3[] = {
        {
                .ep_end = DRD_EP_MAX_H3,
                .ep_fifosz_shift = 9,
                .ep_fifosz_reg = MUSB2_VAL_FIFOSZ_512,
        },
        {
                .ep_end = -1,
        },
};

struct awusbdrd_softc {
        struct musbotg_softc    sc;
        struct resource         *res[2];
        clk_t                   clk;
        hwreset_t               reset;
        phy_t                   phy;
        struct bus_space        bs;
        int                     flags;
};

static struct resource_spec awusbdrd_spec[] = {
        { SYS_RES_MEMORY,       0,      RF_ACTIVE },
        { SYS_RES_IRQ,          0,      RF_ACTIVE },
        { -1, 0 }
};

#define REMAPFLAG       0x8000
#define REGDECL(a, b)   [(a)] = ((b) | REMAPFLAG)

/* Allwinner USB DRD register mappings */
static const uint16_t awusbdrd_regmap[] = {
        REGDECL(MUSB2_REG_EPFIFO(0),    0x0000),
        REGDECL(MUSB2_REG_EPFIFO(1),    0x0004),
        REGDECL(MUSB2_REG_EPFIFO(2),    0x0008),
        REGDECL(MUSB2_REG_EPFIFO(3),    0x000c),
        REGDECL(MUSB2_REG_EPFIFO(4),    0x0010),
        REGDECL(MUSB2_REG_EPFIFO(5),    0x0014),
        REGDECL(MUSB2_REG_POWER,        0x0040),
        REGDECL(MUSB2_REG_DEVCTL,       0x0041),
        REGDECL(MUSB2_REG_EPINDEX,      0x0042),
        REGDECL(MUSB2_REG_INTTX,        0x0044),
        REGDECL(MUSB2_REG_INTRX,        0x0046),
        REGDECL(MUSB2_REG_INTTXE,       0x0048),
        REGDECL(MUSB2_REG_INTRXE,       0x004a),
        REGDECL(MUSB2_REG_INTUSB,       0x004c),
        REGDECL(MUSB2_REG_INTUSBE,      0x0050),
        REGDECL(MUSB2_REG_FRAME,        0x0054),
        REGDECL(MUSB2_REG_TESTMODE,     0x007c),
        REGDECL(MUSB2_REG_TXMAXP,       0x0080),
        REGDECL(MUSB2_REG_TXCSRL,       0x0082),
        REGDECL(MUSB2_REG_TXCSRH,       0x0083),
        REGDECL(MUSB2_REG_RXMAXP,       0x0084),
        REGDECL(MUSB2_REG_RXCSRL,       0x0086),
        REGDECL(MUSB2_REG_RXCSRH,       0x0087),
        REGDECL(MUSB2_REG_RXCOUNT,      0x0088),
        REGDECL(MUSB2_REG_TXTI,         0x008c),
        REGDECL(MUSB2_REG_TXNAKLIMIT,   0x008d),
        REGDECL(MUSB2_REG_RXNAKLIMIT,   0x008f),
        REGDECL(MUSB2_REG_RXTI,         0x008e),
        REGDECL(MUSB2_REG_TXFIFOSZ,     0x0090),
        REGDECL(MUSB2_REG_TXFIFOADD,    0x0092),
        REGDECL(MUSB2_REG_RXFIFOSZ,     0x0094),
        REGDECL(MUSB2_REG_RXFIFOADD,    0x0096),
        REGDECL(MUSB2_REG_FADDR,        0x0098),
        REGDECL(MUSB2_REG_TXFADDR(0),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(0),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(0), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(0),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(0),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(0), 0x009f),
        REGDECL(MUSB2_REG_TXFADDR(1),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(1),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(1), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(1),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(1),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(1), 0x009f),
        REGDECL(MUSB2_REG_TXFADDR(2),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(2),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(2), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(2),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(2),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(2), 0x009f),
        REGDECL(MUSB2_REG_TXFADDR(3),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(3),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(3), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(3),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(3),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(3), 0x009f),
        REGDECL(MUSB2_REG_TXFADDR(4),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(4),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(4), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(4),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(4),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(4), 0x009f),
        REGDECL(MUSB2_REG_TXFADDR(5),   0x0098),
        REGDECL(MUSB2_REG_TXHADDR(5),   0x009a),
        REGDECL(MUSB2_REG_TXHUBPORT(5), 0x009b),
        REGDECL(MUSB2_REG_RXFADDR(5),   0x009c),
        REGDECL(MUSB2_REG_RXHADDR(5),   0x009e),
        REGDECL(MUSB2_REG_RXHUBPORT(5), 0x009f),
        REGDECL(MUSB2_REG_CONFDATA,     0x00c0),
};

static bus_size_t
awusbdrd_reg(bus_size_t o)
{
        bus_size_t v;

        KASSERT(o < nitems(awusbdrd_regmap),
            ("%s: Invalid register %#lx", __func__, o));
        if (o >= nitems(awusbdrd_regmap))
                return (o);

        v = awusbdrd_regmap[o];

        KASSERT((v & REMAPFLAG) != 0, ("%s: reg %#lx not in regmap",
            __func__, o));

        return (v & ~REMAPFLAG);
}

static int
awusbdrd_filt(bus_size_t o)
{
        switch (o) {
        case MUSB2_REG_MISC:
        case MUSB2_REG_RXDBDIS:
        case MUSB2_REG_TXDBDIS:
                return (1);
        default:
                return (0);
        }
}

static uint8_t
awusbdrd_bs_r_1(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o)
{
        struct bus_space *bs = t;

        switch (o) {
        case MUSB2_REG_HWVERS:
                return (0);     /* no known equivalent */
        }

        return (bus_space_read_1(bs_parent_space(bs), h, awusbdrd_reg(o)));
}

static uint8_t
awusbdrd_bs_r_1_noconf(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o)
{

        /*
         * There is no confdata register on some SoCs, return the same
         * magic value as Linux.
         */
        if (o == MUSB2_REG_CONFDATA)
                return (0xde);

        return (awusbdrd_bs_r_1(t, h, o));
}


static uint16_t
awusbdrd_bs_r_2(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o)
{
        struct bus_space *bs = t;

        if (awusbdrd_filt(o) != 0)
                return (0);
        return bus_space_read_2(bs_parent_space(bs), h, awusbdrd_reg(o));
}

static void
awusbdrd_bs_w_1(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    uint8_t v)
{
        struct bus_space *bs = t;

        if (awusbdrd_filt(o) != 0)
                return;

        bus_space_write_1(bs_parent_space(bs), h, awusbdrd_reg(o), v);
}

static void
awusbdrd_bs_w_2(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    uint16_t v)
{
        struct bus_space *bs = t;

        if (awusbdrd_filt(o) != 0)
                return;

        bus_space_write_2(bs_parent_space(bs), h, awusbdrd_reg(o), v);
}

static void
awusbdrd_bs_rm_1(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    uint8_t *d, bus_size_t c)
{
        struct bus_space *bs = t;

        bus_space_read_multi_1(bs_parent_space(bs), h, awusbdrd_reg(o), d, c);
}

static void
awusbdrd_bs_rm_4(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    uint32_t *d, bus_size_t c)
{
        struct bus_space *bs = t;

        bus_space_read_multi_4(bs_parent_space(bs), h, awusbdrd_reg(o), d, c);
}

static void
awusbdrd_bs_wm_1(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    const uint8_t *d, bus_size_t c)
{
        struct bus_space *bs = t;

        if (awusbdrd_filt(o) != 0)
                return;

        bus_space_write_multi_1(bs_parent_space(bs), h, awusbdrd_reg(o), d, c);
}

static void
awusbdrd_bs_wm_4(awusb_bs_tag t, bus_space_handle_t h, bus_size_t o,
    const uint32_t *d, bus_size_t c)
{
        struct bus_space *bs = t;

        if (awusbdrd_filt(o) != 0)
                return;

        bus_space_write_multi_4(bs_parent_space(bs), h, awusbdrd_reg(o), d, c);
}

static void
awusbdrd_intr(void *arg)
{
        struct awusbdrd_softc *sc = arg;
        uint8_t intusb;
        uint16_t inttx, intrx;

        intusb = MUSB2_READ_1(&sc->sc, MUSB2_REG_INTUSB);
        inttx = MUSB2_READ_2(&sc->sc, MUSB2_REG_INTTX);
        intrx = MUSB2_READ_2(&sc->sc, MUSB2_REG_INTRX);
        if (intusb == 0 && inttx == 0 && intrx == 0)
                return;

        if (intusb)
                MUSB2_WRITE_1(&sc->sc, MUSB2_REG_INTUSB, intusb);
        if (inttx)
                MUSB2_WRITE_2(&sc->sc, MUSB2_REG_INTTX, inttx);
        if (intrx)
                MUSB2_WRITE_2(&sc->sc, MUSB2_REG_INTRX, intrx);

        musbotg_interrupt(arg, intrx, inttx, intusb);
}

static int
awusbdrd_probe(device_t dev)
{
        if (!ofw_bus_status_okay(dev))
                return (ENXIO);

        if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
                return (ENXIO);

        device_set_desc(dev, "Allwinner USB DRD");
        return (BUS_PROBE_DEFAULT);
}

static int
awusbdrd_attach(device_t dev)
{
        char usb_mode[24];
        struct awusbdrd_softc *sc;
        uint8_t musb_mode;
        int phy_mode;
        int error;

        sc = device_get_softc(dev);
        sc->flags = ofw_bus_search_compatible(dev, compat_data)->ocd_data;

        error = bus_alloc_resources(dev, awusbdrd_spec, sc->res);
        if (error != 0)
                return (error);

        musb_mode = MUSB2_HOST_MODE;    /* default */
        phy_mode = PHY_USB_MODE_HOST;
        if (OF_getprop(ofw_bus_get_node(dev), "dr_mode",
            &usb_mode, sizeof(usb_mode)) > 0) {
                usb_mode[sizeof(usb_mode) - 1] = 0;
                if (strcasecmp(usb_mode, "host") == 0) {
                        musb_mode = MUSB2_HOST_MODE;
                        phy_mode = PHY_USB_MODE_HOST;
                } else if (strcasecmp(usb_mode, "peripheral") == 0) {
                        musb_mode = MUSB2_DEVICE_MODE;
                        phy_mode = PHY_USB_MODE_DEVICE;
                } else if (strcasecmp(usb_mode, "otg") == 0) {
                        /*
                         * XXX phy has PHY_USB_MODE_OTG, but MUSB does not have
                         * it.  It's not clear how to propagate mode changes
                         * from phy layer (that detects them) to MUSB.
                         */
                        musb_mode = MUSB2_DEVICE_MODE;
                        phy_mode = PHY_USB_MODE_DEVICE;
                } else {
                        device_printf(dev, "Invalid FDT dr_mode: %s\n",
                            usb_mode);
                }
        }

        /* AHB gate clock is required */
        error = clk_get_by_ofw_index(dev, 0, 0, &sc->clk);
        if (error != 0)
                goto fail;

        /* AHB reset is only present on some SoCs */
        (void)hwreset_get_by_ofw_idx(dev, 0, 0, &sc->reset);

        /* Enable clocks */
        error = clk_enable(sc->clk);
        if (error != 0) {
                device_printf(dev, "failed to enable clock: %d\n", error);
                goto fail;
        }
        if (sc->reset != NULL) {
                error = hwreset_deassert(sc->reset);
                if (error != 0) {
                        device_printf(dev, "failed to de-assert reset: %d\n",
                            error);
                        goto fail;
                }
        }

        /* XXX not sure if this is universally needed. */
        (void)phy_get_by_ofw_name(dev, 0, "usb", &sc->phy);
        if (sc->phy != NULL) {
                device_printf(dev, "setting phy mode %d\n", phy_mode);
                if (musb_mode == MUSB2_HOST_MODE) {
                        error = phy_enable(sc->phy);
                        if (error != 0) {
                                device_printf(dev, "Could not enable phy\n");
                                goto fail;
                        }
                }
                error = phy_usb_set_mode(sc->phy, phy_mode);
                if (error != 0) {
                        device_printf(dev, "Could not set phy mode\n");
                        goto fail;
                }
        }

        sc->sc.sc_bus.parent = dev;
        sc->sc.sc_bus.devices = sc->sc.sc_devices;
        sc->sc.sc_bus.devices_max = MUSB2_MAX_DEVICES;
        sc->sc.sc_bus.dma_bits = 32;

        error = usb_bus_mem_alloc_all(&sc->sc.sc_bus, USB_GET_DMA_TAG(dev),
            NULL);
        if (error != 0) {
                error = ENOMEM;
                goto fail;
        }

#if defined(__arm__)
        sc->bs.bs_parent = rman_get_bustag(sc->res[0]);
#elif defined(__aarch64__) || defined(__riscv)
        sc->bs.bs_cookie = rman_get_bustag(sc->res[0]);
#endif

        if ((sc->flags & AWUSB_NO_CONFDATA) == AWUSB_NO_CONFDATA)
                sc->bs.bs_r_1 = awusbdrd_bs_r_1_noconf;
        else
                sc->bs.bs_r_1 = awusbdrd_bs_r_1;
        sc->bs.bs_r_2 = awusbdrd_bs_r_2;
        sc->bs.bs_w_1 = awusbdrd_bs_w_1;
        sc->bs.bs_w_2 = awusbdrd_bs_w_2;
        sc->bs.bs_rm_1 = awusbdrd_bs_rm_1;
        sc->bs.bs_rm_4 = awusbdrd_bs_rm_4;
        sc->bs.bs_wm_1 = awusbdrd_bs_wm_1;
        sc->bs.bs_wm_4 = awusbdrd_bs_wm_4;

        sc->sc.sc_io_tag = &sc->bs;
        sc->sc.sc_io_hdl = rman_get_bushandle(sc->res[0]);
        sc->sc.sc_io_size = rman_get_size(sc->res[0]);

        sc->sc.sc_bus.bdev = device_add_child(dev, "usbus", DEVICE_UNIT_ANY);
        if (sc->sc.sc_bus.bdev == NULL) {
                error = ENXIO;
                goto fail;
        }
        device_set_ivars(sc->sc.sc_bus.bdev, &sc->sc.sc_bus);
        sc->sc.sc_id = 0;
        sc->sc.sc_platform_data = sc;
        sc->sc.sc_mode = musb_mode;
        if (ofw_bus_is_compatible(dev, "allwinner,sun8i-h3-musb")) {
                sc->sc.sc_ep_cfg = musbotg_ep_allwinner_h3;
                sc->sc.sc_ep_max = DRD_EP_MAX_H3;
        } else {
                sc->sc.sc_ep_cfg = musbotg_ep_allwinner;
                sc->sc.sc_ep_max = DRD_EP_MAX;
        }

        error = bus_setup_intr(dev, sc->res[1], INTR_MPSAFE | INTR_TYPE_BIO,
            NULL, awusbdrd_intr, sc, &sc->sc.sc_intr_hdl);
        if (error != 0)
                goto fail;

        /* Enable PIO mode */
        bus_write_1(sc->res[0], MUSB2_REG_AWIN_VEND0, VEND0_PIO_MODE);

#ifdef __arm__
        /* Map SRAMD area to USB0 (sun4i/sun7i only) */
        switch (allwinner_soc_family()) {
        case ALLWINNERSOC_SUN4I:
        case ALLWINNERSOC_SUN7I:
                a10_map_to_otg();
                break;
        }
#endif

        error = musbotg_init(&sc->sc);
        if (error != 0)
                goto fail;

        error = device_probe_and_attach(sc->sc.sc_bus.bdev);
        if (error != 0)
                goto fail;

        musbotg_vbus_interrupt(&sc->sc, 1);     /* XXX VBUS */

        return (0);

fail:
        if (sc->phy != NULL) {
                if (musb_mode == MUSB2_HOST_MODE)
                        (void)phy_disable(sc->phy);
                phy_release(sc->phy);
        }
        if (sc->reset != NULL) {
                hwreset_assert(sc->reset);
                hwreset_release(sc->reset);
        }
        if (sc->clk != NULL)
                clk_release(sc->clk);
        bus_release_resources(dev, awusbdrd_spec, sc->res);
        return (error);
}

static int
awusbdrd_detach(device_t dev)
{
        struct awusbdrd_softc *sc;
        int error;

        error = bus_generic_detach(dev);
        if (error != 0)
                return (error);

        sc = device_get_softc(dev);

        musbotg_uninit(&sc->sc);
        error = bus_teardown_intr(dev, sc->res[1], sc->sc.sc_intr_hdl);
        if (error != 0)
                return (error);

        usb_bus_mem_free_all(&sc->sc.sc_bus, NULL);

        if (sc->phy != NULL) {
                if (sc->sc.sc_mode == MUSB2_HOST_MODE)
                        phy_disable(sc->phy);
                phy_release(sc->phy);
        }
        if (sc->reset != NULL) {
                if (hwreset_assert(sc->reset) != 0)
                        device_printf(dev, "failed to assert reset\n");
                hwreset_release(sc->reset);
        }
        if (sc->clk != NULL)
                clk_release(sc->clk);

        bus_release_resources(dev, awusbdrd_spec, sc->res);

        return (0);
}

static device_method_t awusbdrd_methods[] = {
        /* Device interface */
        DEVMETHOD(device_probe,         awusbdrd_probe),
        DEVMETHOD(device_attach,        awusbdrd_attach),
        DEVMETHOD(device_detach,        awusbdrd_detach),
        DEVMETHOD(device_suspend,       bus_generic_suspend),
        DEVMETHOD(device_resume,        bus_generic_resume),
        DEVMETHOD(device_shutdown,      bus_generic_shutdown),

        DEVMETHOD_END
};

static driver_t awusbdrd_driver = {
        .name = "musbotg",
        .methods = awusbdrd_methods,
        .size = sizeof(struct awusbdrd_softc),
};

DRIVER_MODULE(musbotg, simplebus, awusbdrd_driver, 0, 0);
MODULE_DEPEND(musbotg, usb, 1, 1, 1);