// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2009 Wind River Systems, Inc.
 * Tom Rix <Tom.Rix@windriver.com>
 *
 * This file is a rewrite of the usb device part of
 * repository git.omapzoom.org/repo/u-boot.git, branch master,
 * file cpu/omap3/fastboot.c
 *
 * This is the unique part of its copyright :
 *
 * -------------------------------------------------------------------------
 *
 * (C) Copyright 2008 - 2009
 * Windriver, <www.windriver.com>
 * Tom Rix <Tom.Rix@windriver.com>
 *
 * -------------------------------------------------------------------------
 *
 * The details of connecting the device to the uboot usb device subsystem
 * came from the old omap3 repository www.sakoman.net/u-boot-omap3.git,
 * branch omap3-dev-usb, file drivers/usb/usbdcore_musb.c
 *
 * This is the unique part of its copyright :
 *
 * -------------------------------------------------------------------------
 *
 * (C) Copyright 2008 Texas Instruments Incorporated.
 *
 * Based on
 * u-boot OMAP1510 USB drivers (drivers/usbdcore_omap1510.c)
 * twl4030 init based on linux (drivers/i2c/chips/twl4030_usb.c)
 *
 * Author: Diego Dompe (diego.dompe@ridgerun.com)
 *         Atin Malaviya (atin.malaviya@gmail.com)
 *
 * -------------------------------------------------------------------------
 */

#include <common.h>
#include <serial.h>
#include <usbdevice.h>
#include <usb/udc.h>
#include "../gadget/ep0.h"
#include "musb_core.h"
#if defined(CONFIG_USB_OMAP3)
#include "omap3.h"
#elif defined(CONFIG_USB_AM35X)
#include "am35x.h"
#endif

/* Define MUSB_DEBUG for debugging */
/* #define MUSB_DEBUG */
#include "musb_debug.h"

#define MAX_ENDPOINT 15

#define GET_ENDPOINT(dev,ep)                                            \
(((struct usb_device_instance *)(dev))->bus->endpoint_array + ep)

#define SET_EP0_STATE(s)                                                \
do {                                                                    \
        if ((0 <= (s)) && (SET_ADDRESS >= (s))) {                       \
                if ((s) != ep0_state) {                                 \
                        if ((debug_setup) && (debug_level > 1))         \
                                serial_printf("INFO : Changing state "  \
                                              "from %s to %s in %s at " \
                                              "line %d\n",              \
                                              ep0_state_strings[ep0_state],\
                                              ep0_state_strings[s],     \
                                              __PRETTY_FUNCTION__,      \
                                              __LINE__);                \
                        ep0_state = s;                                  \
                }                                                       \
        } else {                                                        \
                if (debug_level > 0)                                    \
                        serial_printf("Error at %s %d with setting "    \
                                      "state %d is invalid\n",          \
                                      __PRETTY_FUNCTION__, __LINE__, s); \
        }                                                               \
} while (0)

/* static implies these initialized to 0 or NULL */
static int debug_setup;
static int debug_level;
static struct musb_epinfo epinfo[MAX_ENDPOINT * 2 + 2];
static enum ep0_state_enum {
        IDLE = 0,
        TX,
        RX,
        SET_ADDRESS
} ep0_state = IDLE;
static char *ep0_state_strings[4] = {
        "IDLE",
        "TX",
        "RX",
        "SET_ADDRESS",
};

static struct urb *ep0_urb;
struct usb_endpoint_instance *ep0_endpoint;
static struct usb_device_instance *udc_device;
static int enabled;

#ifdef MUSB_DEBUG
static void musb_db_regs(void)
{
        u8 b;
        u16 w;

        b = readb(&musbr->faddr);
        serial_printf("\tfaddr   0x%2.2x\n", b);

        b = readb(&musbr->power);
        musb_print_pwr(b);

        w = readw(&musbr->ep[0].ep0.csr0);
        musb_print_csr0(w);

        b = readb(&musbr->devctl);
        musb_print_devctl(b);

        b = readb(&musbr->ep[0].ep0.configdata);
        musb_print_config(b);

        w = readw(&musbr->frame);
        serial_printf("\tframe   0x%4.4x\n", w);

        b = readb(&musbr->index);
        serial_printf("\tindex   0x%2.2x\n", b);

        w = readw(&musbr->ep[1].epN.rxmaxp);
        musb_print_rxmaxp(w);

        w = readw(&musbr->ep[1].epN.rxcsr);
        musb_print_rxcsr(w);

        w = readw(&musbr->ep[1].epN.txmaxp);
        musb_print_txmaxp(w);

        w = readw(&musbr->ep[1].epN.txcsr);
        musb_print_txcsr(w);
}
#else
#define musb_db_regs()
#endif /* DEBUG_MUSB */

static void musb_peri_softconnect(void)
{
        u8 power, devctl;

        /* Power off MUSB */
        power = readb(&musbr->power);
        power &= ~MUSB_POWER_SOFTCONN;
        writeb(power, &musbr->power);

        /* Read intr to clear */
        readb(&musbr->intrusb);
        readw(&musbr->intrrx);
        readw(&musbr->intrtx);

        udelay(1000 * 1000); /* 1 sec */

        /* Power on MUSB */
        power = readb(&musbr->power);
        power |= MUSB_POWER_SOFTCONN;
        /*
         * The usb device interface is usb 1.1
         * Disable 2.0 high speed by clearring the hsenable bit.
         */
        power &= ~MUSB_POWER_HSENAB;
        writeb(power, &musbr->power);

        /* Check if device is in b-peripheral mode */
        devctl = readb(&musbr->devctl);
        if (!(devctl & MUSB_DEVCTL_BDEVICE) ||
            (devctl & MUSB_DEVCTL_HM)) {
                serial_printf("ERROR : Unsupport USB mode\n");
                serial_printf("Check that mini-B USB cable is attached "
                              "to the device\n");
        }

        if (debug_setup && (debug_level > 1))
                musb_db_regs();
}

static void musb_peri_reset(void)
{
        if ((debug_setup) && (debug_level > 1))
                serial_printf("INFO : %s reset\n", __PRETTY_FUNCTION__);

        if (ep0_endpoint)
                ep0_endpoint->endpoint_address = 0xff;

        /* Sync sw and hw addresses */
        writeb(udc_device->address, &musbr->faddr);

        SET_EP0_STATE(IDLE);
}

static void musb_peri_resume(void)
{
        /* noop */
}

static void musb_peri_ep0_stall(void)
{
        u16 csr0;

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        csr0 |= MUSB_CSR0_P_SENDSTALL;
        writew(csr0, &musbr->ep[0].ep0.csr0);
        if ((debug_setup) && (debug_level > 1))
                serial_printf("INFO : %s stall\n", __PRETTY_FUNCTION__);
}

static void musb_peri_ep0_ack_req(void)
{
        u16 csr0;

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        csr0 |= MUSB_CSR0_P_SVDRXPKTRDY;
        writew(csr0, &musbr->ep[0].ep0.csr0);
}

static void musb_ep0_tx_ready(void)
{
        u16 csr0;

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        csr0 |= MUSB_CSR0_TXPKTRDY;
        writew(csr0, &musbr->ep[0].ep0.csr0);
}

static void musb_ep0_tx_ready_and_last(void)
{
        u16 csr0;

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        csr0 |= (MUSB_CSR0_TXPKTRDY | MUSB_CSR0_P_DATAEND);
        writew(csr0, &musbr->ep[0].ep0.csr0);
}

static void musb_peri_ep0_last(void)
{
        u16 csr0;

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        csr0 |= MUSB_CSR0_P_DATAEND;
        writew(csr0, &musbr->ep[0].ep0.csr0);
}

static void musb_peri_ep0_set_address(void)
{
        u8 faddr;
        writeb(udc_device->address, &musbr->faddr);

        /* Verify */
        faddr = readb(&musbr->faddr);
        if (udc_device->address == faddr) {
                SET_EP0_STATE(IDLE);
                usbd_device_event_irq(udc_device, DEVICE_ADDRESS_ASSIGNED, 0);
                if ((debug_setup) && (debug_level > 1))
                        serial_printf("INFO : %s Address set to %d\n",
                                      __PRETTY_FUNCTION__, udc_device->address);
        } else {
                if (debug_level > 0)
                        serial_printf("ERROR : %s Address missmatch "
                                      "sw %d vs hw %d\n",
                                      __PRETTY_FUNCTION__,
                                      udc_device->address, faddr);
        }
}

static void musb_peri_rx_ack(unsigned int ep)
{
        u16 peri_rxcsr;

        peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr);
        peri_rxcsr &= ~MUSB_RXCSR_RXPKTRDY;
        writew(peri_rxcsr, &musbr->ep[ep].epN.rxcsr);
}

static void musb_peri_tx_ready(unsigned int ep)
{
        u16 peri_txcsr;

        peri_txcsr = readw(&musbr->ep[ep].epN.txcsr);
        peri_txcsr |= MUSB_TXCSR_TXPKTRDY;
        writew(peri_txcsr, &musbr->ep[ep].epN.txcsr);
}

static void musb_peri_ep0_zero_data_request(int err)
{
        musb_peri_ep0_ack_req();

        if (err) {
                musb_peri_ep0_stall();
                SET_EP0_STATE(IDLE);
        } else {

                musb_peri_ep0_last();

                /* USBD state */
                switch (ep0_urb->device_request.bRequest) {
                case USB_REQ_SET_ADDRESS:
                        if ((debug_setup) && (debug_level > 1))
                                serial_printf("INFO : %s received set "
                                              "address\n", __PRETTY_FUNCTION__);
                        break;

                case USB_REQ_SET_CONFIGURATION:
                        if ((debug_setup) && (debug_level > 1))
                                serial_printf("INFO : %s Configured\n",
                                              __PRETTY_FUNCTION__);
                        usbd_device_event_irq(udc_device, DEVICE_CONFIGURED, 0);
                        break;
                }

                /* EP0 state */
                if (USB_REQ_SET_ADDRESS == ep0_urb->device_request.bRequest) {
                        SET_EP0_STATE(SET_ADDRESS);
                } else {
                        SET_EP0_STATE(IDLE);
                }
        }
}

static void musb_peri_ep0_rx_data_request(void)
{
        /*
         * This is the completion of the data OUT / RX
         *
         * Host is sending data to ep0 that is not
         * part of setup.  This comes from the cdc_recv_setup
         * op that is device specific.
         *
         */
        musb_peri_ep0_ack_req();

        ep0_endpoint->rcv_urb = ep0_urb;
        ep0_urb->actual_length = 0;
        SET_EP0_STATE(RX);
}

static void musb_peri_ep0_tx_data_request(int err)
{
        if (err) {
                musb_peri_ep0_stall();
                SET_EP0_STATE(IDLE);
        } else {
                musb_peri_ep0_ack_req();

                ep0_endpoint->tx_urb = ep0_urb;
                ep0_endpoint->sent = 0;
                SET_EP0_STATE(TX);
        }
}

static void musb_peri_ep0_idle(void)
{
        u16 count0;
        int err;
        u16 csr0;

        /*
         * Verify addresses
         * A lot of confusion can be caused if the address
         * in software, udc layer, does not agree with the
         * hardware.  Since the setting of the hardware address
         * must be set after the set address request, the
         * usb state machine is out of sync for a few frame.
         * It is a good idea to run this check when changes
         * are made to the state machine.
         */
        if ((debug_level > 0) &&
            (ep0_state != SET_ADDRESS)) {
                u8 faddr;

                faddr = readb(&musbr->faddr);
                if (udc_device->address != faddr) {
                        serial_printf("ERROR : %s addresses do not"
                                      "match sw %d vs hw %d\n",
                                      __PRETTY_FUNCTION__,
                                      udc_device->address, faddr);
                        udelay(1000 * 1000);
                        hang();
                }
        }

        csr0 = readw(&musbr->ep[0].ep0.csr0);

        if (!(MUSB_CSR0_RXPKTRDY & csr0))
                goto end;

        count0 = readw(&musbr->ep[0].ep0.count0);
        if (count0 == 0)
                goto end;

        if (count0 != 8) {
                if ((debug_setup) && (debug_level > 1))
                        serial_printf("WARN : %s SETUP incorrect size %d\n",
                                      __PRETTY_FUNCTION__, count0);
                musb_peri_ep0_stall();
                goto end;
        }

        read_fifo(0, count0, &ep0_urb->device_request);

        if (debug_level > 2)
                print_usb_device_request(&ep0_urb->device_request);

        if (ep0_urb->device_request.wLength == 0) {
                err = ep0_recv_setup(ep0_urb);

                /* Zero data request */
                musb_peri_ep0_zero_data_request(err);
        } else {
                /* Is data coming or going ? */
                u8 reqType = ep0_urb->device_request.bmRequestType;

                if (USB_REQ_DEVICE2HOST == (reqType & USB_REQ_DIRECTION_MASK)) {
                        err = ep0_recv_setup(ep0_urb);
                        /* Device to host */
                        musb_peri_ep0_tx_data_request(err);
                } else {
                        /*
                         * Host to device
                         *
                         * The RX routine will call ep0_recv_setup
                         * when the data packet has arrived.
                         */
                        musb_peri_ep0_rx_data_request();
                }
        }

end:
        return;
}

static void musb_peri_ep0_rx(void)
{
        /*
         * This is the completion of the data OUT / RX
         *
         * Host is sending data to ep0 that is not
         * part of setup.  This comes from the cdc_recv_setup
         * op that is device specific.
         *
         * Pass the data back to driver ep0_recv_setup which
         * should give the cdc_recv_setup the chance to handle
         * the rx
         */
        u16 csr0;
        u16 count0;

        if (debug_level > 3) {
                if (0 != ep0_urb->actual_length) {
                        serial_printf("%s finished ? %d of %d\n",
                                      __PRETTY_FUNCTION__,
                                      ep0_urb->actual_length,
                                      ep0_urb->device_request.wLength);
                }
        }

        if (ep0_urb->device_request.wLength == ep0_urb->actual_length) {
                musb_peri_ep0_last();
                SET_EP0_STATE(IDLE);
                ep0_recv_setup(ep0_urb);
                return;
        }

        csr0 = readw(&musbr->ep[0].ep0.csr0);
        if (!(MUSB_CSR0_RXPKTRDY & csr0))
                return;

        count0 = readw(&musbr->ep[0].ep0.count0);

        if (count0) {
                struct usb_endpoint_instance *endpoint;
                u32 length;
                u8 *data;

                endpoint = ep0_endpoint;
                if (endpoint && endpoint->rcv_urb) {
                        struct urb *urb = endpoint->rcv_urb;
                        unsigned int remaining_space = urb->buffer_length -
                                urb->actual_length;

                        if (remaining_space) {
                                int urb_bad = 0; /* urb is good */

                                if (count0 > remaining_space)
                                        length = remaining_space;
                                else
                                        length = count0;

                                data = (u8 *) urb->buffer_data;
                                data += urb->actual_length;

                                /* The common musb fifo reader */
                                read_fifo(0, length, data);

                                musb_peri_ep0_ack_req();

                                /*
                                 * urb's actual_length is updated in
                                 * usbd_rcv_complete
                                 */
                                usbd_rcv_complete(endpoint, length, urb_bad);

                        } else {
                                if (debug_level > 0)
                                        serial_printf("ERROR : %s no space in "
                                                      "rcv buffer\n",
                                                      __PRETTY_FUNCTION__);
                        }
                } else {
                        if (debug_level > 0)
                                serial_printf("ERROR : %s problem with "
                                              "endpoint\n",
                                              __PRETTY_FUNCTION__);
                }
        } else {
                if (debug_level > 0)
                        serial_printf("ERROR : %s with nothing to do\n",
                                      __PRETTY_FUNCTION__);
        }
}

static void musb_peri_ep0_tx(void)
{
        u16 csr0;
        int transfer_size = 0;
        unsigned int p, pm;

        csr0 = readw(&musbr->ep[0].ep0.csr0);

        /* Check for pending tx */
        if (csr0 & MUSB_CSR0_TXPKTRDY)
                goto end;

        /* Check if this is the last packet sent */
        if (ep0_endpoint->sent >= ep0_urb->actual_length) {
                SET_EP0_STATE(IDLE);
                goto end;
        }

        transfer_size = ep0_urb->actual_length - ep0_endpoint->sent;
        /* Is the transfer size negative ? */
        if (transfer_size <= 0) {
                if (debug_level > 0)
                        serial_printf("ERROR : %s problem with the"
                                      " transfer size %d\n",
                                      __PRETTY_FUNCTION__,
                                      transfer_size);
                SET_EP0_STATE(IDLE);
                goto end;
        }

        /* Truncate large transfers to the fifo size */
        if (transfer_size > ep0_endpoint->tx_packetSize)
                transfer_size = ep0_endpoint->tx_packetSize;

        write_fifo(0, transfer_size, &ep0_urb->buffer[ep0_endpoint->sent]);
        ep0_endpoint->sent += transfer_size;

        /* Done or more to send ? */
        if (ep0_endpoint->sent >= ep0_urb->actual_length)
                musb_ep0_tx_ready_and_last();
        else
                musb_ep0_tx_ready();

        /* Wait a bit */
        pm = 10;
        for (p = 0; p < pm; p++) {
                csr0 = readw(&musbr->ep[0].ep0.csr0);
                if (!(csr0 & MUSB_CSR0_TXPKTRDY))
                        break;

                /* Double the delay. */
                udelay(1 << pm);
        }

        if ((ep0_endpoint->sent >= ep0_urb->actual_length) && (p < pm))
                SET_EP0_STATE(IDLE);

end:
        return;
}

static void musb_peri_ep0(void)
{
        u16 csr0;

        if (SET_ADDRESS == ep0_state)
                return;

        csr0 = readw(&musbr->ep[0].ep0.csr0);

        /* Error conditions */
        if (MUSB_CSR0_P_SENTSTALL & csr0) {
                csr0 &= ~MUSB_CSR0_P_SENTSTALL;
                writew(csr0, &musbr->ep[0].ep0.csr0);
                SET_EP0_STATE(IDLE);
        }
        if (MUSB_CSR0_P_SETUPEND & csr0) {
                csr0 |= MUSB_CSR0_P_SVDSETUPEND;
                writew(csr0, &musbr->ep[0].ep0.csr0);
                SET_EP0_STATE(IDLE);
                if ((debug_setup) && (debug_level > 1))
                        serial_printf("WARN: %s SETUPEND\n",
                                      __PRETTY_FUNCTION__);
        }

        /* Normal states */
        if (IDLE == ep0_state)
                musb_peri_ep0_idle();

        if (TX == ep0_state)
                musb_peri_ep0_tx();

        if (RX == ep0_state)
                musb_peri_ep0_rx();
}

static void musb_peri_rx_ep(unsigned int ep)
{
        u16 peri_rxcount;
        u8 peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr);

        if (!(peri_rxcsr & MUSB_RXCSR_RXPKTRDY)) {
                if (debug_level > 0)
                        serial_printf("ERROR : %s %d without MUSB_RXCSR_RXPKTRDY set\n",
                                      __PRETTY_FUNCTION__, ep);
                return;
        }

        peri_rxcount = readw(&musbr->ep[ep].epN.rxcount);
        if (peri_rxcount) {
                struct usb_endpoint_instance *endpoint;
                u32 length;
                u8 *data;

                endpoint = GET_ENDPOINT(udc_device, ep);
                if (endpoint && endpoint->rcv_urb) {
                        struct urb *urb = endpoint->rcv_urb;
                        unsigned int remaining_space = urb->buffer_length -
                                urb->actual_length;

                        if (remaining_space) {
                                int urb_bad = 0; /* urb is good */

                                if (peri_rxcount > remaining_space)
                                        length = remaining_space;
                                else
                                        length = peri_rxcount;

                                data = (u8 *) urb->buffer_data;
                                data += urb->actual_length;

                                /* The common musb fifo reader */
                                read_fifo(ep, length, data);

                                musb_peri_rx_ack(ep);

                                /*
                                 * urb's actual_length is updated in
                                 * usbd_rcv_complete
                                 */
                                usbd_rcv_complete(endpoint, length, urb_bad);

                        } else {
                                if (debug_level > 0)
                                        serial_printf("ERROR : %s %d no space "
                                                      "in rcv buffer\n",
                                                      __PRETTY_FUNCTION__, ep);
                        }
                } else {
                        if (debug_level > 0)
                                serial_printf("ERROR : %s %d problem with "
                                              "endpoint\n",
                                              __PRETTY_FUNCTION__, ep);
                }

        } else {
                if (debug_level > 0)
                        serial_printf("ERROR : %s %d with nothing to do\n",
                                      __PRETTY_FUNCTION__, ep);
        }
}

static void musb_peri_rx(u16 intr)
{
        unsigned int ep;

        /* Check for EP0 */
        if (0x01 & intr)
                musb_peri_ep0();

        for (ep = 1; ep < 16; ep++) {
                if ((1 << ep) & intr)
                        musb_peri_rx_ep(ep);
        }
}

static void musb_peri_tx(u16 intr)
{
        /* Check for EP0 */
        if (0x01 & intr)
                musb_peri_ep0_tx();

        /*
         * Use this in the future when handling epN tx
         *
         * u8 ep;
         *
         * for (ep = 1; ep < 16; ep++) {
         *      if ((1 << ep) & intr) {
         *              / * handle tx for this endpoint * /
         *      }
         * }
         */
}

void udc_irq(void)
{
        /* This is a high freq called function */
        if (enabled) {
                u8 intrusb;

                intrusb = readb(&musbr->intrusb);

                /*
                 * See drivers/usb/gadget/mpc8xx_udc.c for
                 * state diagram going from detached through
                 * configuration.
                 */
                if (MUSB_INTR_RESUME & intrusb) {
                        usbd_device_event_irq(udc_device,
                                              DEVICE_BUS_ACTIVITY, 0);
                        musb_peri_resume();
                }

                musb_peri_ep0();

                if (MUSB_INTR_RESET & intrusb) {
                        usbd_device_event_irq(udc_device, DEVICE_RESET, 0);
                        musb_peri_reset();
                }

                if (MUSB_INTR_DISCONNECT & intrusb) {
                        /* cable unplugged from hub/host */
                        usbd_device_event_irq(udc_device, DEVICE_RESET, 0);
                        musb_peri_reset();
                        usbd_device_event_irq(udc_device, DEVICE_HUB_RESET, 0);
                }

                if (MUSB_INTR_SOF & intrusb) {
                        usbd_device_event_irq(udc_device,
                                              DEVICE_BUS_ACTIVITY, 0);
                        musb_peri_resume();
                }

                if (MUSB_INTR_SUSPEND & intrusb) {
                        usbd_device_event_irq(udc_device,
                                              DEVICE_BUS_INACTIVE, 0);
                }

                if (ep0_state != SET_ADDRESS) {
                        u16 intrrx, intrtx;

                        intrrx = readw(&musbr->intrrx);
                        intrtx = readw(&musbr->intrtx);

                        if (intrrx)
                                musb_peri_rx(intrrx);

                        if (intrtx)
                                musb_peri_tx(intrtx);
                } else {
                        if (MUSB_INTR_SOF & intrusb) {
                                u8 faddr;
                                faddr = readb(&musbr->faddr);
                                /*
                                 * Setting of the address can fail.
                                 * Normally it succeeds the second time.
                                 */
                                if (udc_device->address != faddr)
                                        musb_peri_ep0_set_address();
                        }
                }
        }
}

void udc_set_nak(int ep_num)
{
        /* noop */
}

void udc_unset_nak(int ep_num)
{
        /* noop */
}

int udc_endpoint_write(struct usb_endpoint_instance *endpoint)
{
        int ret = 0;

        /* Transmit only if the hardware is available */
        if (endpoint->tx_urb && endpoint->state == 0) {
                unsigned int ep = endpoint->endpoint_address &
                        USB_ENDPOINT_NUMBER_MASK;

                u16 peri_txcsr = readw(&musbr->ep[ep].epN.txcsr);

                /* Error conditions */
                if (peri_txcsr & MUSB_TXCSR_P_UNDERRUN) {
                        peri_txcsr &= ~MUSB_TXCSR_P_UNDERRUN;
                        writew(peri_txcsr, &musbr->ep[ep].epN.txcsr);
                }

                if (debug_level > 1)
                        musb_print_txcsr(peri_txcsr);

                /* Check if a packet is waiting to be sent */
                if (!(peri_txcsr & MUSB_TXCSR_TXPKTRDY)) {
                        u32 length;
                        u8 *data;
                        struct urb *urb = endpoint->tx_urb;
                        unsigned int remaining_packet = urb->actual_length -
                                endpoint->sent;

                        if (endpoint->tx_packetSize < remaining_packet)
                                length = endpoint->tx_packetSize;
                        else
                                length = remaining_packet;

                        data = (u8 *) urb->buffer;
                        data += endpoint->sent;

                        /* common musb fifo function */
                        write_fifo(ep, length, data);

                        musb_peri_tx_ready(ep);

                        endpoint->last = length;
                        /* usbd_tx_complete will take care of updating 'sent' */
                        usbd_tx_complete(endpoint);
                }
        } else {
                if (debug_level > 0)
                        serial_printf("ERROR : %s Problem with urb %p "
                                      "or ep state %d\n",
                                      __PRETTY_FUNCTION__,
                                      endpoint->tx_urb, endpoint->state);
        }

        return ret;
}

void udc_setup_ep(struct usb_device_instance *device, unsigned int id,
                  struct usb_endpoint_instance *endpoint)
{
        if (0 == id) {
                /* EP0 */
                ep0_endpoint = endpoint;
                ep0_endpoint->endpoint_address = 0xff;
                ep0_urb = usbd_alloc_urb(device, endpoint);
        } else if (MAX_ENDPOINT >= id) {
                int ep_addr;

                /* Check the direction */
                ep_addr = endpoint->endpoint_address;
                if (USB_DIR_IN == (ep_addr & USB_ENDPOINT_DIR_MASK)) {
                        /* IN */
                        epinfo[(id * 2) + 1].epsize = endpoint->tx_packetSize;
                } else {
                        /* OUT */
                        epinfo[id * 2].epsize = endpoint->rcv_packetSize;
                }

                musb_configure_ep(&epinfo[0], ARRAY_SIZE(epinfo));
        } else {
                if (debug_level > 0)
                        serial_printf("ERROR : %s endpoint request %d "
                                      "exceeds maximum %d\n",
                                      __PRETTY_FUNCTION__, id, MAX_ENDPOINT);
        }
}

void udc_connect(void)
{
        /* noop */
}

void udc_disconnect(void)
{
        /* noop */
}

void udc_enable(struct usb_device_instance *device)
{
        /* Save the device structure pointer */
        udc_device = device;

        enabled = 1;
}

void udc_disable(void)
{
        enabled = 0;
}

void udc_startup_events(struct usb_device_instance *device)
{
        /* The DEVICE_INIT event puts the USB device in the state STATE_INIT. */
        usbd_device_event_irq(device, DEVICE_INIT, 0);

        /*
         * The DEVICE_CREATE event puts the USB device in the state
         * STATE_ATTACHED.
         */
        usbd_device_event_irq(device, DEVICE_CREATE, 0);

        /* Resets the address to 0 */
        usbd_device_event_irq(device, DEVICE_RESET, 0);

        udc_enable(device);
}

int udc_init(void)
{
        int ret;
        int ep_loop;

        ret = musb_platform_init();
        if (ret < 0)
                goto end;

        /* Configure all the endpoint FIFO's and start usb controller */
        musbr = musb_cfg.regs;

        /* Initialize the endpoints */
        for (ep_loop = 0; ep_loop <= MAX_ENDPOINT * 2; ep_loop++) {
                epinfo[ep_loop].epnum = (ep_loop / 2) + 1;
                epinfo[ep_loop].epdir = ep_loop % 2; /* OUT, IN */
                epinfo[ep_loop].epsize = 0;
        }

        musb_peri_softconnect();

        ret = 0;
end:

        return ret;
}