Re: [PATCH v3 2/2] usb: gadget: Add xilinx axi usb2 device support

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 




Ping

Thanks,
Sundeep.B.S.

On Tue, Jun 10, 2014 at 5:34 PM,  <subbaraya.sundeep.bhatta@xxxxxxxxxx> wrote:
> From: Subbaraya Sundeep Bhatta <sbhatta@xxxxxxxxxx>
>
> This patch adds xilinx axi usb2 device driver support
>
> Signed-off-by: Subbaraya Sundeep Bhatta <sbhatta@xxxxxxxxxx>
> ---
> Changes for v3:
>         - Added pullup function
>         - Modified error handling
>         - Fixed all v2 comments except DMA interrupt handling
>           since polling seems to be faster.
> Please refer to below message thread:
>         http://www.kernelhub.org/?p=2&msg=481724
>
> Changes for v2:
>         - Added Resume
>         - Added Remote wakeup
>         - Fixed v1 comments
>
>  drivers/usb/gadget/Kconfig      |   14 +
>  drivers/usb/gadget/Makefile     |    1 +
>  drivers/usb/gadget/udc-xilinx.c | 2273 +++++++++++++++++++++++++++++++++++++++
>  3 files changed, 2288 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/usb/gadget/udc-xilinx.c
>
> diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
> index ba18e9c..83560dc 100644
> --- a/drivers/usb/gadget/Kconfig
> +++ b/drivers/usb/gadget/Kconfig
> @@ -459,6 +459,20 @@ config USB_EG20T
>           ML7213/ML7831 is companion chip for Intel Atom E6xx series.
>           ML7213/ML7831 is completely compatible for Intel EG20T PCH.
>
> +config USB_GADGET_XILINX
> +       tristate "Xilinx USB Driver"
> +       depends on COMPILE_TEST
> +       help
> +         USB peripheral controller driver for Xilinx AXI USB2 device.
> +         Xilinx AXI USB2 device is a soft IP which supports both full
> +         and high speed USB 2.0 data transfers. It has seven configurable
> +         endpoints(bulk or interrupt or isochronous), as well as
> +         endpoint zero(for control transfers).
> +
> +         Say "y" to link the driver statically, or "m" to build a
> +         dynamically linked module called "xilinx_udc" and force all
> +         gadget drivers to also be dynamically linked.
> +
>  #
>  # LAST -- dummy/emulated controller
>  #
> diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
> index 49514ea..dc6dd41 100644
> --- a/drivers/usb/gadget/Makefile
> +++ b/drivers/usb/gadget/Makefile
> @@ -35,6 +35,7 @@ obj-$(CONFIG_USB_FUSB300)     += fusb300_udc.o
>  obj-$(CONFIG_USB_FOTG210_UDC)  += fotg210-udc.o
>  obj-$(CONFIG_USB_MV_U3D)       += mv_u3d_core.o
>  obj-$(CONFIG_USB_GR_UDC)       += gr_udc.o
> +obj-$(CONFIG_USB_GADGET_XILINX)        += udc-xilinx.o
>
>  # USB Functions
>  usb_f_acm-y                    := f_acm.o
> diff --git a/drivers/usb/gadget/udc-xilinx.c b/drivers/usb/gadget/udc-xilinx.c
> new file mode 100644
> index 0000000..f377e8a
> --- /dev/null
> +++ b/drivers/usb/gadget/udc-xilinx.c
> @@ -0,0 +1,2273 @@
> +/*
> + * Xilinx USB peripheral controller driver
> + *
> + * Copyright (C) 2004 by Thomas Rathbone
> + * Copyright (C) 2005 by HP Labs
> + * Copyright (C) 2005 by David Brownell
> + * Copyright (C) 2010 - 2014 Xilinx, Inc.
> + *
> + * Some parts of this driver code is based on the driver for at91-series
> + * USB peripheral controller (at91_udc.c).
> + *
> + * This program is free software; you can redistribute it
> + * and/or modify it under the terms of the GNU General Public
> + * License as published by the Free Software Foundation;
> + * either version 2 of the License, or (at your option) any
> + * later version.
> + */
> +
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/dma-mapping.h>
> +#include "gadget_chips.h"
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/module.h>
> +#include <linux/of_address.h>
> +#include <linux/of_device.h>
> +#include <linux/of_platform.h>
> +#include <linux/of_irq.h>
> +#include <linux/prefetch.h>
> +#include <linux/usb/ch9.h>
> +#include <linux/usb/gadget.h>
> +
> +/* Register offsets for the USB device.*/
> +#define XUSB_EP0_CONFIG_OFFSET         0x0000  /* EP0 Config Reg Offset */
> +#define XUSB_SETUP_PKT_ADDR_OFFSET     0x0080  /* Setup Packet Address */
> +#define XUSB_ADDRESS_OFFSET            0x0100  /* Address Register */
> +#define XUSB_CONTROL_OFFSET            0x0104  /* Control Register */
> +#define XUSB_STATUS_OFFSET             0x0108  /* Status Register */
> +#define XUSB_FRAMENUM_OFFSET           0x010C  /* Frame Number Register */
> +#define XUSB_IER_OFFSET                        0x0110  /* Interrupt Enable Register */
> +#define XUSB_BUFFREADY_OFFSET          0x0114  /* Buffer Ready Register */
> +#define XUSB_TESTMODE_OFFSET           0x0118  /* Test Mode Register */
> +#define XUSB_DMA_RESET_OFFSET          0x0200  /* DMA Soft Reset Register */
> +#define XUSB_DMA_CONTROL_OFFSET                0x0204  /* DMA Control Register */
> +#define XUSB_DMA_DSAR_ADDR_OFFSET      0x0208  /* DMA source Address Reg */
> +#define XUSB_DMA_DDAR_ADDR_OFFSET      0x020C  /* DMA destination Addr Reg */
> +#define XUSB_DMA_LENGTH_OFFSET         0x0210  /* DMA Length Register */
> +#define XUSB_DMA_STATUS_OFFSET         0x0214  /* DMA Status Register */
> +
> +/* Endpoint Configuration Space offsets */
> +#define XUSB_EP_CFGSTATUS_OFFSET       0x00    /* Endpoint Config Status  */
> +#define XUSB_EP_BUF0COUNT_OFFSET       0x08    /* Buffer 0 Count */
> +#define XUSB_EP_BUF1COUNT_OFFSET       0x0C    /* Buffer 1 Count */
> +
> +#define XUSB_CONTROL_USB_READY_MASK    0x80000000 /* USB ready Mask */
> +#define XUSB_CONTROL_USB_RMTWAKE_MASK  0x40000000 /* Remote wake up mask */
> +
> +/* Interrupt register related masks.*/
> +#define XUSB_STATUS_GLOBAL_INTR_MASK   0x80000000 /* Global Intr Enable */
> +#define XUSB_STATUS_DMADONE_MASK       0x04000000 /* DMA done Mask */
> +#define XUSB_STATUS_DMAERR_MASK                0x02000000 /* DMA Error Mask */
> +#define XUSB_STATUS_DMABUSY_MASK       0x80000000 /* DMA Error Mask */
> +#define XUSB_STATUS_RESUME_MASK                0x01000000 /* USB Resume Mask */
> +#define XUSB_STATUS_RESET_MASK         0x00800000 /* USB Reset Mask */
> +#define XUSB_STATUS_SUSPEND_MASK       0x00400000 /* USB Suspend Mask */
> +#define XUSB_STATUS_DISCONNECT_MASK    0x00200000 /* USB Disconnect Mask */
> +#define XUSB_STATUS_FIFO_BUFF_RDY_MASK 0x00100000 /* FIFO Buff Ready Mask */
> +#define XUSB_STATUS_FIFO_BUFF_FREE_MASK        0x00080000 /* FIFO Buff Free Mask */
> +#define XUSB_STATUS_SETUP_PACKET_MASK  0x00040000 /* Setup packet received */
> +#define XUSB_STATUS_EP1_BUFF2_COMP_MASK        0x00000200 /* EP 1 Buff 2 Processed */
> +#define XUSB_STATUS_EP1_BUFF1_COMP_MASK        0x00000002 /* EP 1 Buff 1 Processed */
> +#define XUSB_STATUS_EP0_BUFF2_COMP_MASK        0x00000100 /* EP 0 Buff 2 Processed */
> +#define XUSB_STATUS_EP0_BUFF1_COMP_MASK        0x00000001 /* EP 0 Buff 1 Processed */
> +#define XUSB_STATUS_HIGH_SPEED_MASK    0x00010000 /* USB Speed Mask */
> +/* Suspend,Reset,Suspend and Disconnect Mask */
> +#define XUSB_STATUS_INTR_EVENT_MASK    0x01E00000
> +/* Buffers  completion Mask */
> +#define XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK    0x0000FEFF
> +/* Mask for buffer 0 and buffer 1 completion for all Endpoints */
> +#define XUSB_STATUS_INTR_BUFF_COMP_SHIFT_MASK  0x00000101
> +#define XUSB_STATUS_EP_BUFF2_SHIFT     8          /* EP buffer offset */
> +
> +/* Endpoint Configuration Status Register */
> +#define XUSB_EP_CFG_VALID_MASK         0x80000000 /* Endpoint Valid bit */
> +#define XUSB_EP_CFG_STALL_MASK         0x40000000 /* Endpoint Stall bit */
> +#define XUSB_EP_CFG_DATA_TOGGLE_MASK   0x08000000 /* Endpoint Data toggle */
> +
> +/* USB device specific global configuration constants.*/
> +#define XUSB_MAX_ENDPOINTS             8       /* Maximum End Points */
> +#define XUSB_EP_NUMBER_ZERO            0       /* End point Zero */
> +/* DPRAM is the source address for DMA transfer */
> +#define XUSB_DMA_READ_FROM_DPRAM       0x80000000
> +#define XUSB_DMA_DMASR_BUSY            0x80000000 /* DMA busy */
> +#define XUSB_DMA_DMASR_ERROR           0x40000000 /* DMA Error */
> +/*
> + * When this bit is set, the DMA buffer ready bit is set by hardware upon
> + * DMA transfer completion.
> + */
> +#define XUSB_DMA_BRR_CTRL              0x40000000 /* DMA bufready ctrl bit */
> +/* Phase States */
> +#define SETUP_PHASE                    0x0000  /* Setup Phase */
> +#define DATA_PHASE                     0x0001  /* Data Phase */
> +#define STATUS_PHASE                   0x0002  /* Status Phase */
> +
> +#define EP0_MAX_PACKET         64 /* Endpoint 0 maximum packet length */
> +
> +/* container_of helper macros */
> +#define to_udc(g)       container_of((g), struct xusb_udc, gadget)
> +#define to_xusb_ep(ep)  container_of((ep), struct xusb_ep, ep_usb)
> +#define to_xusb_req(req) container_of((req), struct xusb_req, usb_req)
> +
> +/**
> + * struct xusb_req - Xilinx USB device request structure
> + * @usb_req: Linux usb request structure
> + * @queue: usb device request queue
> + * @ep: pointer to xusb_endpoint structure
> + */
> +struct xusb_req {
> +       struct usb_request usb_req;
> +       struct list_head queue;
> +       struct xusb_ep *ep;
> +};
> +
> +/**
> + * struct xusb_ep - USB end point structure.
> + * @ep_usb: usb endpoint instance
> + * @queue: endpoint message queue
> + * @udc: xilinx usb peripheral driver instance pointer
> + * @desc: pointer to the usb endpoint descriptor
> + * @rambase: the endpoint buffer address
> + * @offset: the endpoint register offset value
> + * @name: name of the endpoint
> + * @epnumber: endpoint number
> + * @maxpacket: maximum packet size the endpoint can store
> + * @buffer0count: the size of the packet recieved in the first buffer
> + * @buffer1count: the size of the packet received in the second buffer
> + * @buffer0ready: the busy state of first buffer
> + * @buffer1ready: the busy state of second buffer
> + * @eptype: endpoint transfer type (BULK, INTERRUPT)
> + * @curbufnum: current buffer of endpoint that will be processed next
> + * @is_in: endpoint direction (IN or OUT)
> + * @is_iso: endpoint type(isochronous or non isochronous)
> + */
> +struct xusb_ep {
> +       struct usb_ep ep_usb;
> +       struct list_head queue;
> +       struct xusb_udc *udc;
> +       const struct usb_endpoint_descriptor *desc;
> +       u32 rambase;
> +       u32 offset;
> +       char name[4];
> +       u16 epnumber;
> +       u16 maxpacket;
> +       u16 buffer0count;
> +       u16 buffer1count;
> +       u8 buffer0ready;
> +       u8 buffer1ready;
> +       u8 eptype;
> +       u8 curbufnum;
> +       u8 is_in;
> +       u8 is_iso;
> +};
> +
> +/**
> + * struct xusb_udc -  USB peripheral driver structure
> + * @gadget: USB gadget driver instance
> + * @ep: an array of endpoint structures
> + * @driver: pointer to the usb gadget driver instance
> + * @setup: usb_ctrlrequest structure for control requests
> + * @req: pointer to dummy request for get status command
> + * @dev: pointer to device structure in gadget
> + * @usb_state: device in suspended state or not
> + * @remote_wkp: remote wakeup enabled by host
> + * @setupseqtx: tx status
> + * @setupseqrx: rx status
> + * @read_fn: function pointer to read device registers
> + * @write_fn: function pointer to write to device registers
> + * @base_address: the usb device base address
> + * @lock: instance of spinlock
> + * @dma_enabled: flag indicating whether the dma is included in the system
> + */
> +struct xusb_udc {
> +       struct usb_gadget gadget;
> +       struct xusb_ep ep[8];
> +       struct usb_gadget_driver *driver;
> +       struct usb_ctrlrequest setup;
> +       struct xusb_req *req;
> +       struct device *dev;
> +       u32 usb_state;
> +       u32 remote_wkp;
> +       u32 setupseqtx;
> +       u32 setupseqrx;
> +       unsigned int (*read_fn)(void __iomem *);
> +       void (*write_fn)(void __iomem *, u32, u32);
> +       void __iomem *base_address;
> +       spinlock_t lock;
> +       bool dma_enabled;
> +};
> +
> +/* Endpoint buffer start addresses in the core */
> +static u32 rambase[8] = { 0x22, 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500,
> +                       0x1600 };
> +
> +static const char driver_name[] = "xilinx-udc";
> +static const char ep0name[] = "ep0";
> +
> +/* Control endpoint configuration.*/
> +static const struct usb_endpoint_descriptor config_bulk_out_desc = {
> +       .bLength                = USB_DT_ENDPOINT_SIZE,
> +       .bDescriptorType        = USB_DT_ENDPOINT,
> +       .bEndpointAddress       = USB_DIR_OUT,
> +       .bmAttributes           = USB_ENDPOINT_XFER_BULK,
> +       .wMaxPacketSize         = __constant_cpu_to_le16(64),
> +};
> +
> +/**
> + * xudc_write32 - little endian write to device registers
> + * @addr: base addr of device registers
> + * @offset: register offset
> + * @val: data to be written
> + */
> +static void xudc_write32(void __iomem *addr, u32 offset, u32 val)
> +{
> +       iowrite32(val, addr + offset);
> +}
> +
> +/**
> + * xudc_read32 - little endian read from device registers
> + * @addr: addr of device register
> + * Return: value at addr
> + */
> +static unsigned int xudc_read32(void __iomem *addr)
> +{
> +       return ioread32(addr);
> +}
> +
> +/**
> + * xudc_write32_be - big endian write to device registers
> + * @addr: base addr of device registers
> + * @offset: register offset
> + * @val: data to be written
> + */
> +static void xudc_write32_be(void __iomem *addr, u32 offset, u32 val)
> +{
> +       iowrite32be(val, addr + offset);
> +}
> +
> +/**
> + * xudc_read32_be - big endian read from device registers
> + * @addr: addr of device register
> + * Return: value at addr
> + */
> +static unsigned int xudc_read32_be(void __iomem *addr)
> +{
> +       return ioread32be(addr);
> +}
> +
> +/**
> + * xudc_wrstatus - Sets up the usb device status stages.
> + * @udc: pointer to the usb device controller structure.
> + */
> +static void xudc_wrstatus(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO];
> +       u32 epcfgreg;
> +
> +       epcfgreg = udc->read_fn(udc->base_address + ep0->offset)|
> +                       XUSB_EP_CFG_DATA_TOGGLE_MASK;
> +       udc->write_fn(udc->base_address, ep0->offset, epcfgreg);
> +       udc->write_fn(udc->base_address, ep0->offset + XUSB_EP_BUF0COUNT_OFFSET,
> +                       0);
> +       udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET, 1);
> +}
> +
> +/**
> + * xudc_epconfig - Configures the given endpoint.
> + * @ep: pointer to the usb device endpoint structure.
> + * @udc: pointer to the usb peripheral controller structure.
> + *
> + * This function configures a specific endpoint with the given configuration
> + * data.
> + */
> +static void xudc_epconfig(struct xusb_ep *ep, struct xusb_udc *udc)
> +{
> +       u32 epcfgreg;
> +
> +       /*
> +        * Configure the end point direction, type, Max Packet Size and the
> +        * EP buffer location.
> +        */
> +       epcfgreg = ((ep->is_in << 29) | (ep->eptype << 28) |
> +                       (ep->ep_usb.maxpacket << 15) | (ep->rambase));
> +       udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +
> +       /* Set the Buffer count and the Buffer ready bits.*/
> +       udc->write_fn(udc->base_address, ep->offset + XUSB_EP_BUF0COUNT_OFFSET,
> +                       ep->buffer0count);
> +       udc->write_fn(udc->base_address, ep->offset + XUSB_EP_BUF1COUNT_OFFSET,
> +                       ep->buffer1count);
> +       if (ep->buffer0ready)
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET,
> +                               1 << ep->epnumber);
> +       if (ep->buffer1ready)
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET, 1 <<
> +                                (ep->epnumber + XUSB_STATUS_EP_BUFF2_SHIFT));
> +}
> +
> +/**
> + * xudc_start_dma - Starts DMA transfer.
> + * @ep: pointer to the usb device endpoint structure.
> + * @src: DMA source address.
> + * @dst: DMA destination address.
> + * @length: number of bytes to transfer.
> + *
> + * Return: 0 on success, error code on failure
> + *
> + * This function starts DMA transfer by writing to DMA source,
> + * destination and lenth registers.
> + */
> +static int xudc_start_dma(struct xusb_ep *ep, dma_addr_t src,
> +                               dma_addr_t dst, u32 length)
> +{
> +       struct xusb_udc *udc = ep->udc;
> +       int rc = 0;
> +       u32 timeout = 500;
> +       u32 reg;
> +
> +       /*
> +        * Set the addresses in the DMA source and
> +        * destination registers and then set the length
> +        * into the DMA length register.
> +        */
> +       udc->write_fn(udc->base_address, XUSB_DMA_DSAR_ADDR_OFFSET, src);
> +       udc->write_fn(udc->base_address, XUSB_DMA_DDAR_ADDR_OFFSET, dst);
> +       udc->write_fn(udc->base_address, XUSB_DMA_LENGTH_OFFSET, length);
> +
> +       /*
> +        * Wait till DMA transaction is complete and
> +        * check whether the DMA transaction was
> +        * successful.
> +        */
> +       do {
> +               reg = udc->read_fn(udc->base_address + XUSB_DMA_STATUS_OFFSET);
> +               if (!(reg &  XUSB_DMA_DMASR_BUSY))
> +                       break;
> +
> +               /*
> +                * We can't sleep here, because it's also called from
> +                * interrupt context.
> +                */
> +               timeout--;
> +               if (!timeout) {
> +                       dev_err(udc->dev, "DMA timeout\n");
> +                       return -ETIMEDOUT;
> +               }
> +               udelay(1);
> +       } while (1);
> +
> +       if ((udc->read_fn(udc->base_address + XUSB_DMA_STATUS_OFFSET) &
> +                       XUSB_DMA_DMASR_ERROR) == XUSB_DMA_DMASR_ERROR){
> +               dev_err(udc->dev, "DMA Error\n");
> +               rc = -EINVAL;
> +       }
> +
> +       return rc;
> +}
> +
> +/**
> + * xudc_dma_send - Sends IN data using DMA.
> + * @ep: pointer to the usb device endpoint structure.
> + * @req: pointer to the usb request structure.
> + * @buffer: pointer to data to be sent.
> + * @length: number of bytes to send.
> + *
> + * Return: 0 on success, -EAGAIN if no buffer is free and error
> + *        code on failure.
> + *
> + * This function sends data using DMA.
> + */
> +static int xudc_dma_send(struct xusb_ep *ep, struct xusb_req *req,
> +                       u8 *buffer, u32 length)
> +{
> +       u32 *eprambase;
> +       dma_addr_t src;
> +       dma_addr_t dst;
> +       int ret;
> +       struct xusb_udc *udc = ep->udc;
> +
> +       src = req->usb_req.dma + req->usb_req.actual;
> +       if (req->usb_req.length)
> +               dma_sync_single_for_device(udc->dev, src,
> +                                               length, DMA_TO_DEVICE);
> +       if (!ep->curbufnum && !ep->buffer0ready) {
> +               /* Get the Buffer address and copy the transmit data.*/
> +               eprambase = (u32 __force *)(ep->udc->base_address +
> +                               ep->rambase);
> +               dst = virt_to_phys(eprambase);
> +               udc->write_fn(udc->base_address, ep->offset +
> +                               XUSB_EP_BUF0COUNT_OFFSET, length);
> +               udc->write_fn(udc->base_address, XUSB_DMA_CONTROL_OFFSET,
> +                               XUSB_DMA_BRR_CTRL | (1 << ep->epnumber));
> +               ep->buffer0ready = 1;
> +               ep->curbufnum = 1;
> +       } else if (ep->curbufnum && !ep->buffer1ready) {
> +               /* Get the Buffer address and copy the transmit data.*/
> +               eprambase = (u32 __force *)(ep->udc->base_address +
> +                               ep->rambase + ep->ep_usb.maxpacket);
> +               dst = virt_to_phys(eprambase);
> +               udc->write_fn(ep->udc->base_address, ep->offset +
> +                               XUSB_EP_BUF1COUNT_OFFSET, length);
> +               udc->write_fn(udc->base_address, XUSB_DMA_CONTROL_OFFSET,
> +                               XUSB_DMA_BRR_CTRL | (1 << (ep->epnumber +
> +                               XUSB_STATUS_EP_BUFF2_SHIFT)));
> +               ep->buffer1ready = 1;
> +               ep->curbufnum = 0;
> +       } else {
> +               /* None of ping pong buffers are ready currently .*/
> +               return -EAGAIN;
> +       }
> +
> +       ret = xudc_start_dma(ep, src, dst, length);
> +       return ret;
> +}
> +
> +/**
> + * xudc_dma_receive - Receives OUT data using DMA.
> + * @ep: pointer to the usb device endpoint structure.
> + * @req: pointer to the usb request structure.
> + * @buffer: pointer to storage buffer of received data.
> + * @length: number of bytes to receive.
> + *
> + * Return: 0 on success, -EAGAIN if no buffer is free and error
> + *        code on failure.
> + *
> + * This function receives data using DMA.
> + */
> +static int xudc_dma_receive(struct xusb_ep *ep, struct xusb_req *req,
> +                               u8 *buffer, u32 length)
> +{
> +       u32 *eprambase;
> +       dma_addr_t src;
> +       dma_addr_t dst;
> +       int ret = 0;
> +       struct xusb_udc *udc = ep->udc;
> +
> +       dst = req->usb_req.dma + req->usb_req.actual;
> +
> +       if (!ep->curbufnum && !ep->buffer0ready) {
> +               /* Get the Buffer address and copy the transmit data */
> +               eprambase = (u32 __force *)(ep->udc->base_address +
> +                               ep->rambase);
> +               src = virt_to_phys(eprambase);
> +               udc->write_fn(udc->base_address, XUSB_DMA_CONTROL_OFFSET,
> +                               XUSB_DMA_BRR_CTRL | XUSB_DMA_READ_FROM_DPRAM |
> +                               (1 << ep->epnumber));
> +               ep->buffer0ready = 1;
> +               ep->curbufnum = 1;
> +       } else if (ep->curbufnum && !ep->buffer1ready) {
> +               /* Get the Buffer address and copy the transmit data */
> +               eprambase = (u32 __force *)(ep->udc->base_address +
> +                               ep->rambase + ep->ep_usb.maxpacket);
> +               src = virt_to_phys(eprambase);
> +               udc->write_fn(udc->base_address, XUSB_DMA_CONTROL_OFFSET,
> +                               XUSB_DMA_BRR_CTRL | XUSB_DMA_READ_FROM_DPRAM |
> +                               (1 << (ep->epnumber +
> +                               XUSB_STATUS_EP_BUFF2_SHIFT)));
> +               ep->buffer1ready = 1;
> +               ep->curbufnum = 0;
> +       } else {
> +               /* None of the ping-pong buffers are ready currently */
> +               return -EAGAIN;
> +       }
> +
> +       xudc_start_dma(ep, src, dst, length);
> +       return ret;
> +}
> +
> +/**
> + * xudc_eptxrx - Transmits or receives data to or from an endpoint.
> + * @ep: pointer to the usb endpoint configuration structure.
> + * @req: pointer to the usb request structure.
> + * @bufferptr: pointer to buffer containing the data to be sent.
> + * @bufferlen: The number of data bytes to be sent.
> + *
> + * Return: 0 on success, -EAGAIN if no buffer is free.
> + *
> + * This function copies the transmit/receive data to/from the end point buffer
> + * and enables the buffer for transmission/reception.
> + */
> +static int xudc_eptxrx(struct xusb_ep *ep, struct xusb_req *req,
> +                       u8 *bufferptr, u32 bufferlen)
> +{
> +       u32 *eprambase;
> +       u32 bytestosend;
> +       u8 *temprambase;
> +       int rc = 0;
> +       struct xusb_udc *udc = ep->udc;
> +
> +       bytestosend = bufferlen;
> +       if (udc->dma_enabled) {
> +               if (ep->is_in)
> +                       rc = xudc_dma_send(ep, req, bufferptr, bufferlen);
> +               else
> +                       rc = xudc_dma_receive(ep, req, bufferptr, bufferlen);
> +               return rc;
> +       }
> +       /* Put the transmit buffer into the correct ping-pong buffer.*/
> +       if (!ep->curbufnum && !ep->buffer0ready) {
> +               /* Get the Buffer address and copy the transmit data.*/
> +               eprambase = (u32 __force *)(udc->base_address + ep->rambase);
> +               while (bytestosend > 3) {
> +                       if (ep->is_in)
> +                               *eprambase++ = *(u32 *)bufferptr;
> +                       else
> +                               *(u32 *)bufferptr = *eprambase++;
> +                       bufferptr += 4;
> +                       bytestosend -= 4;
> +               }
> +               temprambase = (u8 *)eprambase;
> +               while (bytestosend--) {
> +                       if (ep->is_in)
> +                               *temprambase++ = *bufferptr++;
> +                       else
> +                               *bufferptr++ = *temprambase++;
> +               }
> +               /*
> +                * Set the Buffer count register with transmit length
> +                * and enable the buffer for transmission.
> +                */
> +               if (ep->is_in)
> +                       udc->write_fn(udc->base_address, ep->offset +
> +                                       XUSB_EP_BUF0COUNT_OFFSET, bufferlen);
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET,
> +                               1 << ep->epnumber);
> +               ep->buffer0ready = 1;
> +               ep->curbufnum = 1;
> +       } else if ((ep->curbufnum == 1) && (!ep->buffer1ready)) {
> +               /* Get the Buffer address and copy the transmit data.*/
> +               eprambase = (u32 __force *)(udc->base_address + ep->rambase +
> +                               ep->ep_usb.maxpacket);
> +               while (bytestosend > 3) {
> +                       if (ep->is_in)
> +                               *eprambase++ = *(u32 *)bufferptr;
> +                       else
> +                               *(u32 *)bufferptr = *eprambase++;
> +                       bufferptr += 4;
> +                       bytestosend -= 4;
> +               }
> +               temprambase = (u8 *)eprambase;
> +               while (bytestosend--) {
> +                       if (ep->is_in)
> +                               *temprambase++ = *bufferptr++;
> +                       else
> +                               *bufferptr++ = *temprambase++;
> +               }
> +               /*
> +                * Set the Buffer count register with transmit
> +                * length and enable the buffer for
> +                * transmission.
> +                */
> +               if (ep->is_in)
> +                       udc->write_fn(udc->base_address, ep->offset +
> +                                       XUSB_EP_BUF1COUNT_OFFSET, bufferlen);
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET,
> +                               1 << (ep->epnumber +
> +                               XUSB_STATUS_EP_BUFF2_SHIFT));
> +               ep->buffer1ready = 1;
> +               ep->curbufnum = 0;
> +       } else {
> +               /* None of the ping-pong buffers are ready currently */
> +               return -EAGAIN;
> +       }
> +       return rc;
> +}
> +
> +/**
> + * xudc_done - Exeutes the endpoint data transfer completion tasks.
> + * @ep: pointer to the usb device endpoint structure.
> + * @req: pointer to the usb request structure.
> + * @status: Status of the data transfer.
> + *
> + * Deletes the message from the queue and updates data transfer completion
> + * status.
> + */
> +static void xudc_done(struct xusb_ep *ep, struct xusb_req *req, int status)
> +{
> +       struct xusb_udc *udc = ep->udc;
> +
> +       list_del_init(&req->queue);
> +
> +       if (req->usb_req.status == -EINPROGRESS)
> +               req->usb_req.status = status;
> +       else
> +               status = req->usb_req.status;
> +
> +       if (status && status != -ESHUTDOWN)
> +               dev_dbg(udc->dev, "%s done %p, status %d\n",
> +                               ep->ep_usb.name, req, status);
> +       /* unmap request if DMA is present*/
> +       if (udc->dma_enabled && ep->epnumber && req->usb_req.length)
> +               usb_gadget_unmap_request(&udc->gadget, &req->usb_req,
> +                                               ep->is_in);
> +
> +       if (req->usb_req.complete) {
> +               spin_unlock(&udc->lock);
> +               req->usb_req.complete(&ep->ep_usb, &req->usb_req);
> +               spin_lock(&udc->lock);
> +       }
> +}
> +
> +/**
> + * xudc_read_fifo - Reads the data from the given endpoint buffer.
> + * @ep: pointer to the usb device endpoint structure.
> + * @req: pointer to the usb request structure.
> + *
> + * Return: 0 if request is completed and -EAGAIN if not completed.
> + *
> + * Pulls OUT packet data from the endpoint buffer.
> + */
> +static int xudc_read_fifo(struct xusb_ep *ep, struct xusb_req *req)
> +{
> +       u8 *buf;
> +       u32 is_short, count, bufferspace;
> +       u8 bufoffset;
> +       u8 two_pkts = 0;
> +       int ret;
> +       int retval = -EAGAIN;
> +       struct xusb_udc *udc = ep->udc;
> +
> +       if ((ep->buffer0ready == 1) && (ep->buffer1ready == 1)) {
> +               dev_dbg(udc->dev, "Packet NOT ready!\n");
> +               return retval;
> +       }
> +top:
> +       if (ep->curbufnum)
> +               bufoffset = XUSB_EP_BUF1COUNT_OFFSET;
> +       else
> +               bufoffset = XUSB_EP_BUF0COUNT_OFFSET;
> +
> +       count = udc->read_fn(udc->base_address + ep->offset + bufoffset);
> +
> +       if (!ep->buffer0ready && !ep->buffer1ready)
> +               two_pkts = 1;
> +
> +       buf = req->usb_req.buf + req->usb_req.actual;
> +       prefetchw(buf);
> +       bufferspace = req->usb_req.length - req->usb_req.actual;
> +       is_short = count < ep->ep_usb.maxpacket;
> +
> +       if (unlikely(!bufferspace)) {
> +               /*
> +                * This happens when the driver's buffer
> +                * is smaller than what the host sent.
> +                * discard the extra data.
> +                */
> +               if (req->usb_req.status != -EOVERFLOW)
> +                       dev_dbg(udc->dev,
> +                                       "%s overflow %d\n",
> +                                       ep->ep_usb.name, count);
> +               req->usb_req.status = -EOVERFLOW;
> +               xudc_done(ep, req, -EOVERFLOW);
> +               return 0;
> +       }
> +
> +       ret = xudc_eptxrx(ep, req, buf, count);
> +       switch (ret) {
> +       case 0:
> +               req->usb_req.actual += min(count, bufferspace);
> +               dev_dbg(udc->dev, "read %s, %d bytes%s req %p %d/%d\n",
> +                       ep->ep_usb.name, count, is_short ? "/S" : "", req,
> +                       req->usb_req.actual, req->usb_req.length);
> +               bufferspace -= count;
> +               /* Completion */
> +               if ((req->usb_req.actual == req->usb_req.length) || is_short) {
> +                       if (udc->dma_enabled && req->usb_req.length)
> +                               dma_sync_single_for_cpu(udc->dev,
> +                                                       req->usb_req.dma,
> +                                                       req->usb_req.actual,
> +                                                       DMA_FROM_DEVICE);
> +                       xudc_done(ep, req, 0);
> +                       return 0;
> +               }
> +               if (two_pkts) {
> +                       two_pkts = 0;
> +                       goto top;
> +               }
> +               break;
> +       case -EAGAIN:
> +               dev_dbg(udc->dev, "receive busy\n");
> +               break;
> +       case -EINVAL:
> +       case -ETIMEDOUT:
> +               /* DMA error, dequeue the request */
> +               xudc_done(ep, req, -ECONNRESET);
> +               retval = 0;
> +               break;
> +       }
> +
> +       return retval;
> +}
> +
> +/**
> + * xudc_write_fifo - Writes data into the given endpoint buffer.
> + * @ep: pointer to the usb device endpoint structure.
> + * @req: pointer to the usb request structure.
> + *
> + * Return: 0 if request is completed and -EAGAIN if not completed.
> + *
> + * Loads endpoint buffer for an IN packet.
> + */
> +static int xudc_write_fifo(struct xusb_ep *ep, struct xusb_req *req)
> +{
> +       u32 max;
> +       u32 length;
> +       int ret;
> +       int retval = -EAGAIN;
> +       struct xusb_udc *udc = ep->udc;
> +       int is_last, is_short = 0;
> +       u8 *buf;
> +
> +       max = le16_to_cpu(ep->desc->wMaxPacketSize);
> +       buf = req->usb_req.buf + req->usb_req.actual;
> +       prefetch(buf);
> +       length = req->usb_req.length - req->usb_req.actual;
> +       length = min(length, max);
> +
> +       ret = xudc_eptxrx(ep, req, buf, length);
> +       switch (ret) {
> +       case 0:
> +               req->usb_req.actual += length;
> +               if (unlikely(length != max)) {
> +                       is_last = is_short = 1;
> +               } else {
> +                       if (likely(req->usb_req.length !=
> +                                  req->usb_req.actual) || req->usb_req.zero)
> +                               is_last = 0;
> +                       else
> +                               is_last = 1;
> +               }
> +               dev_dbg(udc->dev,
> +                       "%s: wrote %s %d bytes%s%s %d left %p\n", __func__,
> +                       ep->ep_usb.name, length, is_last ? "/L" : "",
> +                       is_short ? "/S" : "",
> +                       req->usb_req.length - req->usb_req.actual, req);
> +               /* completion */
> +               if (is_last) {
> +                       xudc_done(ep, req, 0);
> +                       retval = 0;
> +               }
> +               break;
> +       case -EAGAIN:
> +               dev_dbg(udc->dev, "Send busy\n");
> +               break;
> +       case -EINVAL:
> +       case -ETIMEDOUT:
> +               /* DMA error, dequeue the request */
> +               xudc_done(ep, req, -ECONNRESET);
> +               retval = 0;
> +               break;
> +       }
> +
> +       return retval;
> +}
> +
> +/**
> + * xudc_nuke - Cleans up the data transfer message list.
> + * @ep: pointer to the usb device endpoint structure.
> + * @status: Status of the data transfer.
> + */
> +static void xudc_nuke(struct xusb_ep *ep, int status)
> +{
> +       struct xusb_req *req;
> +
> +       while (!list_empty(&ep->queue)) {
> +               req = list_first_entry(&ep->queue, struct xusb_req, queue);
> +               xudc_done(ep, req, status);
> +       }
> +}
> +
> +/**
> + * xudc_ep_set_halt - Stalls/unstalls the given endpoint.
> + * @_ep: pointer to the usb device endpoint structure.
> + * @value: value to indicate stall/unstall.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep_set_halt(struct usb_ep *_ep, int value)
> +{
> +       struct xusb_ep *ep = to_xusb_ep(_ep);
> +       struct xusb_udc *udc;
> +       unsigned long flags;
> +       u32 epcfgreg;
> +
> +       if (!_ep || (!ep->desc && ep->epnumber)) {
> +               pr_debug("%s: bad ep or descriptor\n", __func__);
> +               return -EINVAL;
> +       }
> +       udc = ep->udc;
> +
> +       if (ep->is_in && (!list_empty(&ep->queue)) && value) {
> +               dev_dbg(udc->dev, "requests pending can't halt\n");
> +               return -EAGAIN;
> +       }
> +
> +       if ((ep->buffer0ready == 1) || (ep->buffer1ready == 1)) {
> +               dev_dbg(udc->dev, "HW buffers busy can't halt\n");
> +               return -EAGAIN;
> +       }
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       if (value) {
> +               /* Stall the device.*/
> +               epcfgreg = udc->read_fn(udc->base_address + ep->offset);
> +               epcfgreg |= XUSB_EP_CFG_STALL_MASK;
> +
> +               udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +       } else {
> +               /* Unstall the device.*/
> +               epcfgreg = udc->read_fn(udc->base_address + ep->offset);
> +               epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
> +               udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +               if (ep->epnumber) {
> +                       /* Reset the toggle bit.*/
> +                       epcfgreg = udc->read_fn(ep->udc->base_address +
> +                                                   ep->offset);
> +                       epcfgreg &= ~XUSB_EP_CFG_DATA_TOGGLE_MASK;
> +                       udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +               }
> +       }
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep_enable - Enables the given endpoint.
> + * @ep: pointer to the xusb endpoint structure.
> + * @desc: pointer to usb endpoint descriptor.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int __xudc_ep_enable(struct xusb_ep *ep,
> +                         const struct usb_endpoint_descriptor *desc)
> +{
> +       struct xusb_udc *udc = ep->udc;
> +       u32 tmp;
> +       u8 eptype = 0;
> +       u32 epcfg;
> +       u32 ier;
> +
> +       ep->is_in = ((desc->bEndpointAddress & USB_DIR_IN) != 0);
> +       /* Bit 3...0:endpoint number */
> +       ep->epnumber = (desc->bEndpointAddress & 0x0f);
> +       ep->desc = desc;
> +       ep->ep_usb.desc = desc;
> +       tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
> +       ep->ep_usb.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
> +
> +       switch (tmp) {
> +       case USB_ENDPOINT_XFER_CONTROL:
> +               dev_dbg(udc->dev, "only one control endpoint\n");
> +               /* NON- ISO */
> +               eptype = 0;
> +               return -EINVAL;
> +       case USB_ENDPOINT_XFER_INT:
> +               /* NON- ISO */
> +               eptype = 0;
> +               if (ep->ep_usb.maxpacket > 64)
> +                       goto bogus_max;
> +               break;
> +       case USB_ENDPOINT_XFER_BULK:
> +               /* NON- ISO */
> +               eptype = 0;
> +               switch (ep->ep_usb.maxpacket) {
> +               case 8:
> +               case 16:
> +               case 32:
> +               case 64:
> +               case 512:
> +                       goto ok;
> +               }
> +bogus_max:
> +               dev_dbg(udc->dev, "bogus maxpacket %d\n",
> +                       ep->ep_usb.maxpacket);
> +               return -EINVAL;
> +       case USB_ENDPOINT_XFER_ISOC:
> +               /* ISO */
> +               eptype = 1;
> +               ep->is_iso = 1;
> +               break;
> +       }
> +ok:
> +       ep->eptype = eptype;
> +       ep->buffer0ready = 0;
> +       ep->buffer1ready = 0;
> +       ep->curbufnum = 0;
> +       ep->rambase = rambase[ep->epnumber];
> +       xudc_epconfig(ep, udc);
> +
> +       dev_dbg(udc->dev, "Enable Endpoint %d max pkt is %d\n",
> +               ep->epnumber, ep->ep_usb.maxpacket);
> +
> +       /* Enable the End point.*/
> +       epcfg = udc->read_fn(udc->base_address + ep->offset);
> +       epcfg |= XUSB_EP_CFG_VALID_MASK;
> +       udc->write_fn(udc->base_address, ep->offset, epcfg);
> +       if (ep->epnumber)
> +               ep->rambase <<= 2;
> +
> +       /* Enable buffer completion interrupts for endpoint */
> +       ier = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +       ier |= (XUSB_STATUS_INTR_BUFF_COMP_SHIFT_MASK << ep->epnumber);
> +       udc->write_fn(udc->base_address, XUSB_IER_OFFSET, ier);
> +
> +       /* for OUT endpoint set buffers ready to receive */
> +       if (ep->epnumber && !ep->is_in) {
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET,
> +                               1 << ep->epnumber);
> +               ep->buffer0ready = 1;
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET,
> +                               (1 << (ep->epnumber +
> +                               XUSB_STATUS_EP_BUFF2_SHIFT)));
> +               ep->buffer1ready = 1;
> +       }
> +
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep_enable - Enables the given endpoint.
> + * @_ep: pointer to the usb endpoint structure.
> + * @desc: pointer to usb endpoint descriptor.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep_enable(struct usb_ep *_ep,
> +                         const struct usb_endpoint_descriptor *desc)
> +{
> +       struct xusb_ep *ep;
> +       struct xusb_udc *udc;
> +       unsigned long flags;
> +       int ret;
> +
> +       if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
> +               pr_debug("%s: bad ep or descriptor\n", __func__);
> +               return -EINVAL;
> +       }
> +
> +       ep = to_xusb_ep(_ep);
> +       udc = ep->udc;
> +
> +       if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
> +               dev_dbg(udc->dev, "bogus device state\n");
> +               return -ESHUTDOWN;
> +       }
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +       ret = __xudc_ep_enable(ep, desc);
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +
> +       return ret;
> +}
> +
> +/**
> + * xudc_ep_disable - Disables the given endpoint.
> + * @_ep: pointer to the usb endpoint structure.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep_disable(struct usb_ep *_ep)
> +{
> +       struct xusb_ep *ep;
> +       unsigned long flags;
> +       u32 epcfg;
> +       struct xusb_udc *udc;
> +
> +       if (!_ep) {
> +               pr_debug("%s: invalid ep\n", __func__);
> +               return -EINVAL;
> +       }
> +
> +       ep = to_xusb_ep(_ep);
> +       udc = ep->udc;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       xudc_nuke(ep, -ESHUTDOWN);
> +
> +       /* Restore the endpoint's pristine config */
> +       ep->desc = NULL;
> +       ep->ep_usb.desc = NULL;
> +
> +       dev_dbg(udc->dev, "USB Ep %d disable\n ", ep->epnumber);
> +       /* Disable the endpoint.*/
> +       epcfg = udc->read_fn(udc->base_address + ep->offset);
> +       epcfg &= ~XUSB_EP_CFG_VALID_MASK;
> +       udc->write_fn(udc->base_address, ep->offset, epcfg);
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep_alloc_request - Initializes the request queue.
> + * @_ep: pointer to the usb endpoint structure.
> + * @gfp_flags: Flags related to the request call.
> + *
> + * Return: pointer to request structure on success and a NULL on failure.
> + */
> +static struct usb_request *xudc_ep_alloc_request(struct usb_ep *_ep,
> +                                                gfp_t gfp_flags)
> +{
> +       struct xusb_ep *ep = to_xusb_ep(_ep);
> +       struct xusb_udc *udc;
> +       struct xusb_req *req;
> +
> +       udc = ep->udc;
> +       req = kzalloc(sizeof(*req), gfp_flags);
> +       if (!req) {
> +               dev_err(udc->dev, "not enough memory");
> +               return NULL;
> +       }
> +
> +       req->ep = ep;
> +       INIT_LIST_HEAD(&req->queue);
> +       return &req->usb_req;
> +}
> +
> +/**
> + * xudc_free_request - Releases the request from queue.
> + * @_ep: pointer to the usb device endpoint structure.
> + * @_req: pointer to the usb request structure.
> + */
> +static void xudc_free_request(struct usb_ep *_ep, struct usb_request *_req)
> +{
> +       struct xusb_req *req = to_xusb_req(_req);
> +
> +       kfree(req);
> +}
> +
> +/**
> + * xudc_ep0_queue - Adds the request to endpoint 0 queue.
> + * @ep0: pointer to the xusb endpoint 0 structure.
> + * @req: pointer to the xusb request structure.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int __xudc_ep0_queue(struct xusb_ep *ep0, struct xusb_req *req)
> +{
> +       struct xusb_udc *udc = ep0->udc;
> +       u32 length;
> +       u8 *corebuf;
> +
> +       if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
> +               dev_dbg(udc->dev, "%s, bogus device state\n",
> +                       __func__);
> +               return -EINVAL;
> +       }
> +       if (!list_empty(&ep0->queue)) {
> +               dev_dbg(udc->dev, "%s:ep0 busy\n", __func__);
> +               return -EBUSY;
> +       }
> +
> +       req->usb_req.status = -EINPROGRESS;
> +       req->usb_req.actual = 0;
> +
> +       list_add_tail(&req->queue, &ep0->queue);
> +
> +       if (udc->setup.bRequestType & USB_DIR_IN) {
> +               prefetch(req->usb_req.buf);
> +               length = req->usb_req.length;
> +               corebuf = (void __force *) ((ep0->rambase << 2) +
> +                               udc->base_address);
> +               length = req->usb_req.actual = min_t(u32, length,
> +                               EP0_MAX_PACKET);
> +               memcpy((void *)corebuf, req->usb_req.buf, length);
> +               udc->write_fn(udc->base_address, XUSB_EP_BUF0COUNT_OFFSET,
> +                               length);
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET, 1);
> +       } else {
> +               if (udc->setup.wLength) {
> +                       /* Enable EP0 buffer to receive data */
> +                       udc->write_fn(udc->base_address,
> +                                       XUSB_EP_BUF0COUNT_OFFSET, 0);
> +                       udc->write_fn(udc->base_address,
> +                                       XUSB_BUFFREADY_OFFSET, 1);
> +               } else {
> +                       xudc_wrstatus(udc);
> +               }
> +       }
> +
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep0_queue - Adds the request to endpoint 0 queue.
> + * @_ep: pointer to the usb endpoint 0 structure.
> + * @_req: pointer to the usb request structure.
> + * @gfp_flags: Flags related to the request call.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep0_queue(struct usb_ep *_ep, struct usb_request *_req,
> +                        gfp_t gfp_flags)
> +{
> +       struct xusb_req *req    = to_xusb_req(_req);
> +       struct xusb_ep  *ep0    = to_xusb_ep(_ep);
> +       struct xusb_udc *udc    = ep0->udc;
> +       unsigned long flags;
> +       int ret;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +       ret = __xudc_ep0_queue(ep0, req);
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +
> +       return ret;
> +}
> +
> +/**
> + * xudc_ep_queue - Adds the request to endpoint queue.
> + * @_ep: pointer to the usb endpoint structure.
> + * @_req: pointer to the usb request structure.
> + * @gfp_flags: Flags related to the request call.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
> +                        gfp_t gfp_flags)
> +{
> +       struct xusb_req *req = to_xusb_req(_req);
> +       struct xusb_ep  *ep  = to_xusb_ep(_ep);
> +       struct xusb_udc *udc = ep->udc;
> +       int  ret;
> +       unsigned long flags;
> +
> +       if (!ep->desc) {
> +               dev_dbg(udc->dev, "%s:queing request to disabled %s\n",
> +                               __func__, ep->name);
> +               return -ESHUTDOWN;
> +       }
> +
> +       if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
> +               dev_dbg(udc->dev, "%s, bogus device state\n",
> +                       __func__);
> +               return -EINVAL;
> +       }
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       _req->status = -EINPROGRESS;
> +       _req->actual = 0;
> +
> +       if (udc->dma_enabled) {
> +               ret = usb_gadget_map_request(&udc->gadget,
> +                                       &req->usb_req, ep->is_in);
> +               if (ret) {
> +                       dev_dbg(udc->dev, "gadget_map failed ep%d\n",
> +                                       ep->epnumber);
> +                       spin_unlock_irqrestore(&udc->lock, flags);
> +                       return -EAGAIN;
> +               }
> +       }
> +
> +       /*
> +        * Start processing requests now, if IP buffers are busy with
> +        * previous transactions or data is more than max packet
> +        * size then add requests to queue otherwise finish the work
> +        * and call completion.
> +        */
> +       if (list_empty(&ep->queue)) {
> +               if (ep->is_in) {
> +                       dev_dbg(udc->dev, "xudc_write_fifo from ep_queue\n");
> +                       if (!xudc_write_fifo(ep, req))
> +                               req = NULL;
> +               } else {
> +                       dev_dbg(udc->dev, "xudc_read_fifo from ep_queue\n");
> +                       if (!xudc_read_fifo(ep, req))
> +                               req = NULL;
> +               }
> +       }
> +
> +       if (req != NULL)
> +               list_add_tail(&req->queue, &ep->queue);
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep_dequeue - Removes the request from the queue.
> + * @_ep: pointer to the usb device endpoint structure.
> + * @_req: pointer to the usb request structure.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
> +{
> +       struct xusb_ep *ep      = to_xusb_ep(_ep);
> +       struct xusb_req *req    = to_xusb_req(_req);
> +       struct xusb_udc *udc    = ep->udc;
> +       unsigned long flags;
> +
> +       if (ep->ep_usb.name == ep0name)
> +               return -EINVAL;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +       /* Make sure it's actually queued on this endpoint */
> +       list_for_each_entry(req, &ep->queue, queue) {
> +               if (&req->usb_req == _req)
> +                       break;
> +       }
> +       if (&req->usb_req != _req) {
> +               spin_unlock_irqrestore(&ep->udc->lock, flags);
> +               return -EINVAL;
> +       }
> +       xudc_done(ep, req, -ECONNRESET);
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +
> +       return 0;
> +}
> +
> +/**
> + * xudc_ep0_enable - Enables the given endpoint.
> + * @ep: pointer to the usb endpoint structure.
> + * @desc: pointer to usb endpoint descriptor.
> + *
> + * Return: error always.
> + *
> + * endpoint 0 enable should not be called by gadget layer.
> + */
> +static int xudc_ep0_enable(struct usb_ep *ep,
> +               const struct usb_endpoint_descriptor *desc)
> +{
> +       return -EINVAL;
> +}
> +
> +/**
> + * xudc_ep0_disable - Disables the given endpoint.
> + * @ep: pointer to the usb endpoint structure.
> + *
> + * Return: error always.
> + *
> + * endpoint 0 disable should not be called by gadget layer.
> + */
> +static int xudc_ep0_disable(struct usb_ep *ep)
> +{
> +       return -EINVAL;
> +}
> +
> +static const struct usb_ep_ops xusb_ep0_ops = {
> +       .enable         = xudc_ep0_enable,
> +       .disable        = xudc_ep0_disable,
> +       .alloc_request  = xudc_ep_alloc_request,
> +       .free_request   = xudc_free_request,
> +       .queue          = xudc_ep0_queue,
> +       .dequeue        = xudc_ep_dequeue,
> +       .set_halt       = xudc_ep_set_halt,
> +};
> +
> +static const struct usb_ep_ops xusb_ep_ops = {
> +       .enable         = xudc_ep_enable,
> +       .disable        = xudc_ep_disable,
> +       .alloc_request  = xudc_ep_alloc_request,
> +       .free_request   = xudc_free_request,
> +       .queue          = xudc_ep_queue,
> +       .dequeue        = xudc_ep_dequeue,
> +       .set_halt       = xudc_ep_set_halt,
> +};
> +
> +/**
> + * xudc_get_frame - Reads the current usb frame number.
> + * @gadget: pointer to the usb gadget structure.
> + *
> + * Return: current frame number for success and error value on failure.
> + */
> +static int xudc_get_frame(struct usb_gadget *gadget)
> +{
> +       struct xusb_udc *udc;
> +       int frame;
> +
> +       if (!gadget)
> +               return -ENODEV;
> +
> +       udc = to_udc(gadget);
> +       frame = udc->read_fn(udc->base_address + XUSB_FRAMENUM_OFFSET);
> +       return frame;
> +}
> +
> +/**
> + * xudc_wakeup - Send remote wakeup signal to host
> + * @gadget: pointer to the usb gadget structure.
> + *
> + * Return: 0 on success and error on failure
> + */
> +static int xudc_wakeup(struct usb_gadget *gadget)
> +{
> +       struct xusb_udc *udc = to_udc(gadget);
> +       u32 crtlreg;
> +       int status = -EINVAL;
> +       unsigned long flags;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       /* Remote wake up not enabled by host */
> +       if (!udc->remote_wkp)
> +               goto done;
> +
> +       crtlreg = udc->read_fn(udc->base_address + XUSB_CONTROL_OFFSET);
> +       crtlreg |= XUSB_CONTROL_USB_RMTWAKE_MASK;
> +       /* set remote wake up bit */
> +       udc->write_fn(udc->base_address, XUSB_CONTROL_OFFSET, crtlreg);
> +       /*
> +        * wait for a while and reset remote wake up bit since this bit
> +        * is not cleared by HW after sending remote wakeup to host.
> +        */
> +       mdelay(2);
> +
> +       crtlreg &= ~XUSB_CONTROL_USB_RMTWAKE_MASK;
> +       udc->write_fn(udc->base_address, XUSB_CONTROL_OFFSET, crtlreg);
> +       status = 0;
> +done:
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return status;
> +}
> +
> +/**
> + * xudc_pullup - start/stop USB traffic
> + * @gadget: pointer to the usb gadget structure.
> + * @is_on: flag to start or stop
> + *
> + * Return: 0 always
> + *
> + * This function starts/stops SIE engine of IP based on is_on.
> + */
> +static int xudc_pullup(struct usb_gadget *gadget, int is_on)
> +{
> +       struct xusb_udc *udc = to_udc(gadget);
> +       unsigned long flags;
> +       u32 crtlreg;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       crtlreg = udc->read_fn(udc->base_address + XUSB_CONTROL_OFFSET);
> +       if (is_on)
> +               crtlreg |= XUSB_CONTROL_USB_READY_MASK;
> +       else
> +               crtlreg &= ~XUSB_CONTROL_USB_READY_MASK;
> +
> +       udc->write_fn(udc->base_address, XUSB_CONTROL_OFFSET, crtlreg);
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +
> +       return 0;
> +}
> +
> +/**
> + * xudc_eps_init - initialize endpoints.
> + * @udc: pointer to the usb device controller structure.
> + */
> +static void xudc_eps_init(struct xusb_udc *udc)
> +{
> +       u32 ep_number;
> +       char name[4];
> +
> +       INIT_LIST_HEAD(&udc->gadget.ep_list);
> +
> +       for (ep_number = 0; ep_number < XUSB_MAX_ENDPOINTS; ep_number++) {
> +               struct xusb_ep *ep = &udc->ep[ep_number];
> +
> +               if (ep_number) {
> +                       list_add_tail(&ep->ep_usb.ep_list,
> +                                       &udc->gadget.ep_list);
> +                       usb_ep_set_maxpacket_limit(&ep->ep_usb,
> +                                       (unsigned short) ~0);
> +                       sprintf(name, "ep%d", ep_number);
> +                       strcpy(ep->name, name);
> +                       ep->ep_usb.name = ep->name;
> +                       ep->ep_usb.ops = &xusb_ep_ops;
> +               } else {
> +                       ep->ep_usb.name = ep0name;
> +                       usb_ep_set_maxpacket_limit(&ep->ep_usb, 64);
> +                       ep->ep_usb.ops = &xusb_ep0_ops;
> +               }
> +
> +               ep->udc = udc;
> +               ep->epnumber = ep_number;
> +               ep->desc = NULL;
> +               /*
> +                * The configuration register address offset between
> +                * each endpoint is 0x10.
> +                */
> +               ep->offset = XUSB_EP0_CONFIG_OFFSET +
> +                                       (ep_number * 0x10);
> +               ep->is_in = 0;
> +               ep->is_iso = 0;
> +               ep->maxpacket = 0;
> +               xudc_epconfig(ep, udc);
> +
> +               /* Initialize one queue per endpoint */
> +               INIT_LIST_HEAD(&ep->queue);
> +       }
> +}
> +
> +/**
> + * xudc_stop_activity - Stops any further activity on the device.
> + * @udc: pointer to the usb device controller structure.
> + */
> +static void xudc_stop_activity(struct xusb_udc *udc)
> +{
> +       int i;
> +       struct xusb_ep *ep;
> +
> +       for (i = 0; i < XUSB_MAX_ENDPOINTS; i++) {
> +               ep = &udc->ep[i];
> +               xudc_nuke(ep, -ESHUTDOWN);
> +       }
> +}
> +
> +/**
> + * xudc_start - Starts the device.
> + * @gadget: pointer to the usb gadget structure
> + * @driver: pointer to gadget driver structure
> + *
> + * Return: zero on success and error on failure
> + */
> +static int xudc_start(struct usb_gadget *gadget,
> +                       struct usb_gadget_driver *driver)
> +{
> +       struct xusb_udc *udc    = to_udc(gadget);
> +       struct xusb_ep *ep0     = &udc->ep[XUSB_EP_NUMBER_ZERO];
> +       const struct usb_endpoint_descriptor *desc = &config_bulk_out_desc;
> +       unsigned long flags;
> +       int ret = 0;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       if (udc->driver) {
> +               dev_err(udc->dev, "%s is already bound to %s\n",
> +                               udc->gadget.name, udc->driver->driver.name);
> +               ret = -EBUSY;
> +               goto err;
> +       }
> +
> +       /* hook up the driver */
> +       udc->driver = driver;
> +       udc->gadget.speed = driver->max_speed;
> +
> +       /* Enable the control endpoint. */
> +       ret = __xudc_ep_enable(ep0, desc);
> +
> +       /* Set device address and remote wakeup to 0 */
> +       udc->write_fn(udc->base_address, XUSB_ADDRESS_OFFSET, 0);
> +       udc->remote_wkp = 0;
> +err:
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return ret;
> +}
> +
> +/**
> + * xudc_stop - stops the device.
> + * @gadget: pointer to the usb gadget structure
> + * @driver: pointer to usb gadget driver structure
> + *
> + * Return: zero always
> + */
> +static int xudc_stop(struct usb_gadget *gadget,
> +               struct usb_gadget_driver *driver)
> +{
> +       struct xusb_udc *udc = to_udc(gadget);
> +       unsigned long flags;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       udc->gadget.speed = USB_SPEED_UNKNOWN;
> +       udc->driver = NULL;
> +
> +       /* Set device address and remote wakeup to 0 */
> +       udc->write_fn(udc->base_address, XUSB_ADDRESS_OFFSET, 0);
> +       udc->remote_wkp = 0;
> +
> +       xudc_stop_activity(udc);
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +
> +       return 0;
> +}
> +
> +static const struct usb_gadget_ops xusb_udc_ops = {
> +       .get_frame      = xudc_get_frame,
> +       .wakeup         = xudc_wakeup,
> +       .pullup         = xudc_pullup,
> +       .udc_start      = xudc_start,
> +       .udc_stop       = xudc_stop,
> +};
> +
> +/**
> + * xudc_clear_stall_all_ep - clears stall of every endpoint.
> + * @udc: pointer to the udc structure.
> + */
> +static void xudc_clear_stall_all_ep(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep;
> +       u32 epcfgreg;
> +       int i;
> +
> +       for (i = 0; i < XUSB_MAX_ENDPOINTS; i++) {
> +               ep = &udc->ep[i];
> +               epcfgreg = udc->read_fn(udc->base_address + ep->offset);
> +               epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
> +               udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +               if (ep->epnumber) {
> +                       /* Reset the toggle bit.*/
> +                       epcfgreg = udc->read_fn(ep->udc->base_address +
> +                                               ep->offset);
> +                       epcfgreg &= ~XUSB_EP_CFG_DATA_TOGGLE_MASK;
> +                       udc->write_fn(udc->base_address, ep->offset, epcfgreg);
> +               }
> +       }
> +}
> +
> +/**
> + * xudc_startup_handler - The usb device controller interrupt handler.
> + * @udc: pointer to the udc structure.
> + * @intrstatus: The mask value containing the interrupt sources.
> + *
> + * This function handles the RESET,SUSPEND,RESUME and DISCONNECT interrupts.
> + */
> +static void xudc_startup_handler(struct xusb_udc *udc, u32 intrstatus)
> +{
> +       u32 intrreg;
> +
> +       if (intrstatus & XUSB_STATUS_RESET_MASK) {
> +
> +               dev_dbg(udc->dev, "Reset\n");
> +
> +               if (intrstatus & XUSB_STATUS_HIGH_SPEED_MASK)
> +                       udc->gadget.speed = USB_SPEED_HIGH;
> +               else
> +                       udc->gadget.speed = USB_SPEED_FULL;
> +
> +               xudc_stop_activity(udc);
> +               xudc_clear_stall_all_ep(udc);
> +               udc->write_fn(udc->base_address, XUSB_TESTMODE_OFFSET, 0);
> +
> +               /* Set device address and remote wakeup to 0 */
> +               udc->write_fn(udc->base_address, XUSB_ADDRESS_OFFSET, 0);
> +               udc->remote_wkp = 0;
> +
> +               /* Enable the suspend, resume and disconnect */
> +               intrreg = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +               intrreg |= XUSB_STATUS_SUSPEND_MASK | XUSB_STATUS_RESUME_MASK |
> +                               XUSB_STATUS_DISCONNECT_MASK;
> +               udc->write_fn(udc->base_address, XUSB_IER_OFFSET, intrreg);
> +       }
> +       if (intrstatus & XUSB_STATUS_SUSPEND_MASK) {
> +
> +               dev_dbg(udc->dev, "Suspend\n");
> +
> +               /* Enable the reset, resume and disconnect */
> +               intrreg = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +               intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_RESUME_MASK |
> +                                XUSB_STATUS_DISCONNECT_MASK;
> +               udc->write_fn(udc->base_address, XUSB_IER_OFFSET, intrreg);
> +
> +               udc->usb_state = USB_STATE_SUSPENDED;
> +
> +               if (udc->driver->suspend) {
> +                       spin_unlock(&udc->lock);
> +                       udc->driver->suspend(&udc->gadget);
> +                       spin_lock(&udc->lock);
> +               }
> +       }
> +       if (intrstatus & XUSB_STATUS_RESUME_MASK) {
> +               bool condition = (udc->usb_state != USB_STATE_SUSPENDED);
> +
> +               dev_WARN_ONCE(udc->dev, condition,
> +                               "Resume IRQ while not suspended\n");
> +
> +               dev_dbg(udc->dev, "Resume\n");
> +
> +               /* Enable the reset, suspend and disconnect */
> +               intrreg = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +               intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_SUSPEND_MASK |
> +                                XUSB_STATUS_DISCONNECT_MASK;
> +               udc->write_fn(udc->base_address, XUSB_IER_OFFSET, intrreg);
> +
> +               udc->usb_state = 0;
> +
> +               if (udc->driver->resume) {
> +                       spin_unlock(&udc->lock);
> +                       udc->driver->resume(&udc->gadget);
> +                       spin_lock(&udc->lock);
> +               }
> +       }
> +       if (intrstatus & XUSB_STATUS_DISCONNECT_MASK) {
> +
> +               dev_dbg(udc->dev, "Disconnect\n");
> +
> +               /* Enable the reset, resume and suspend */
> +               intrreg = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +               intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_RESUME_MASK |
> +                                XUSB_STATUS_SUSPEND_MASK;
> +               udc->write_fn(udc->base_address, XUSB_IER_OFFSET, intrreg);
> +
> +               if (udc->driver && udc->driver->disconnect) {
> +                       spin_unlock(&udc->lock);
> +                       udc->driver->disconnect(&udc->gadget);
> +                       spin_lock(&udc->lock);
> +               }
> +       }
> +}
> +
> +/**
> + * xudc_ep0_stall - Stall endpoint zero.
> + * @udc: pointer to the udc structure.
> + *
> + * This function stalls endpoint zero.
> + */
> +static void xudc_ep0_stall(struct xusb_udc *udc)
> +{
> +       u32 epcfgreg;
> +       struct xusb_ep *ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO];
> +
> +       epcfgreg = udc->read_fn(udc->base_address + ep0->offset);
> +       epcfgreg |= XUSB_EP_CFG_STALL_MASK;
> +       udc->write_fn(udc->base_address, ep0->offset, epcfgreg);
> +}
> +
> +/**
> + * xudc_setaddress - executes SET_ADDRESS command
> + * @udc: pointer to the udc structure.
> + *
> + * This function executes USB SET_ADDRESS command
> + */
> +static void xudc_setaddress(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0     = &udc->ep[0];
> +       struct xusb_req *req    = udc->req;
> +       int ret;
> +
> +       req->usb_req.length = 0;
> +       ret = __xudc_ep0_queue(ep0, req);
> +       if (ret == 0)
> +               return;
> +
> +       dev_err(udc->dev, "Can't respond to SET ADDRESS request\n");
> +       xudc_ep0_stall(udc);
> +       return;
> +}
> +
> +/**
> + * xudc_getstatus - executes GET_STATUS command
> + * @udc: pointer to the udc structure.
> + *
> + * This function executes USB GET_STATUS command
> + */
> +static void xudc_getstatus(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0     = &udc->ep[0];
> +       struct xusb_req *req    = udc->req;
> +       struct xusb_ep *target_ep;
> +       u16 status = 0;
> +       u32 epcfgreg;
> +       int epnum;
> +       u32 halt;
> +       int ret;
> +
> +       switch (udc->setup.bRequestType & USB_RECIP_MASK) {
> +       case USB_RECIP_DEVICE:
> +               /* Get device status */
> +               status = 1 << USB_DEVICE_SELF_POWERED;
> +               if (udc->remote_wkp)
> +                       status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
> +               break;
> +       case USB_RECIP_INTERFACE:
> +               break;
> +       case USB_RECIP_ENDPOINT:
> +               epnum = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
> +               target_ep = &udc->ep[epnum];
> +               epcfgreg = udc->read_fn(udc->base_address + target_ep->offset);
> +               halt = epcfgreg & XUSB_EP_CFG_STALL_MASK;
> +               if (udc->setup.wIndex & USB_DIR_IN) {
> +                       if (!target_ep->is_in)
> +                               goto stall;
> +               } else {
> +                       if (target_ep->is_in)
> +                               goto stall;
> +               }
> +               if (halt)
> +                       status = 1 << USB_ENDPOINT_HALT;
> +               break;
> +       default:
> +               goto stall;
> +       }
> +
> +       req->usb_req.length = 2;
> +       *(u16 *)req->usb_req.buf = cpu_to_le16(status);
> +       ret = __xudc_ep0_queue(ep0, req);
> +       if (ret == 0)
> +               return;
> +stall:
> +       dev_err(udc->dev, "Can't respond to getstatus request\n");
> +       xudc_ep0_stall(udc);
> +       return;
> +}
> +
> +/**
> + * xudc_set_clear_feature - Executes the set feature and clear feature commands.
> + * @udc: pointer to the usb device controller structure.
> + *
> + * Processes the SET_FEATURE and CLEAR_FEATURE commands.
> + */
> +static void xudc_set_clear_feature(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0     = &udc->ep[0];
> +       struct xusb_req *req    = udc->req;
> +       struct xusb_ep *target_ep;
> +       u8 endpoint;
> +       u8 outinbit;
> +       u32 epcfgreg;
> +       int flag = (udc->setup.bRequest == USB_REQ_SET_FEATURE ? 1 : 0);
> +       int ret;
> +
> +       switch (udc->setup.bRequestType) {
> +       case USB_RECIP_DEVICE:
> +               switch (udc->setup.wValue) {
> +               case USB_DEVICE_TEST_MODE:
> +                       /*
> +                        * The Test Mode will be executed
> +                        * after the status phase.
> +                        */
> +                       break;
> +               case USB_DEVICE_REMOTE_WAKEUP:
> +                       if (flag)
> +                               udc->remote_wkp = 1;
> +                       else
> +                               udc->remote_wkp = 0;
> +                       break;
> +               default:
> +                       xudc_ep0_stall(udc);
> +                       break;
> +               }
> +               break;
> +       case USB_RECIP_ENDPOINT:
> +               if (!udc->setup.wValue) {
> +                       endpoint = udc->setup.wIndex &
> +                                       USB_ENDPOINT_NUMBER_MASK;
> +                       target_ep = &udc->ep[endpoint];
> +                       outinbit = udc->setup.wIndex &
> +                                       USB_ENDPOINT_DIR_MASK;
> +                       outinbit = outinbit >> 7;
> +
> +                       /* Make sure direction matches.*/
> +                       if (outinbit != target_ep->is_in) {
> +                               xudc_ep0_stall(udc);
> +                               return;
> +                       }
> +                       epcfgreg = udc->read_fn(udc->base_address +
> +                                               target_ep->offset);
> +                       if (!endpoint) {
> +                               /* Clear the stall.*/
> +                               epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
> +                               udc->write_fn(udc->base_address,
> +                                               target_ep->offset, epcfgreg);
> +                       } else {
> +                               if (flag) {
> +                                       epcfgreg |= XUSB_EP_CFG_STALL_MASK;
> +                                       udc->write_fn(udc->base_address,
> +                                                       target_ep->offset,
> +                                                       epcfgreg);
> +                               } else {
> +                                       /* Unstall the endpoint.*/
> +                                       epcfgreg &= ~(XUSB_EP_CFG_STALL_MASK |
> +                                                 XUSB_EP_CFG_DATA_TOGGLE_MASK);
> +                                       udc->write_fn(udc->base_address,
> +                                                       target_ep->offset,
> +                                                       epcfgreg);
> +                               }
> +                       }
> +               }
> +               break;
> +       default:
> +               xudc_ep0_stall(udc);
> +               return;
> +       }
> +
> +       req->usb_req.length = 0;
> +       ret = __xudc_ep0_queue(ep0, req);
> +       if (ret == 0)
> +               return;
> +
> +       dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n");
> +       xudc_ep0_stall(udc);
> +
> +       return;
> +}
> +
> +/**
> + * xudc_handle_setup - Processes the setup packet.
> + * @udc: pointer to the usb device controller structure.
> + *
> + * Process setup packet and delegate to gadget layer.
> + */
> +static void xudc_handle_setup(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0 = &udc->ep[0];
> +       struct usb_ctrlrequest setup;
> +       u32 *ep0rambase;
> +
> +       /* Load up the chapter 9 command buffer.*/
> +       ep0rambase = (u32 __force *) (udc->base_address +
> +                                 XUSB_SETUP_PKT_ADDR_OFFSET);
> +       memcpy((void *)&setup, (void *)ep0rambase, 8);
> +
> +       udc->setup = setup;
> +
> +       udc->setup.wValue = cpu_to_le16(setup.wValue);
> +       udc->setup.wIndex = cpu_to_le16(setup.wIndex);
> +       udc->setup.wLength = cpu_to_le16(setup.wLength);
> +
> +       /* Clear previous requests */
> +       xudc_nuke(ep0, -ECONNRESET);
> +
> +       if (udc->setup.bRequestType & USB_DIR_IN) {
> +               /* Execute the get command.*/
> +               udc->setupseqrx = STATUS_PHASE;
> +               udc->setupseqtx = DATA_PHASE;
> +       } else {
> +               /* Execute the put command.*/
> +               udc->setupseqrx = DATA_PHASE;
> +               udc->setupseqtx = STATUS_PHASE;
> +       }
> +
> +       switch (udc->setup.bRequest) {
> +       case USB_REQ_GET_STATUS:
> +               /* Data+Status phase form udc */
> +               if ((udc->setup.bRequestType &
> +                               (USB_DIR_IN | USB_TYPE_MASK)) !=
> +                               (USB_DIR_IN | USB_TYPE_STANDARD))
> +                       break;
> +               xudc_getstatus(udc);
> +               return;
> +       case USB_REQ_SET_ADDRESS:
> +               /* Status phase from udc */
> +               if (udc->setup.bRequestType != (USB_DIR_OUT |
> +                               USB_TYPE_STANDARD | USB_RECIP_DEVICE))
> +                       break;
> +               xudc_setaddress(udc);
> +               return;
> +       case USB_REQ_CLEAR_FEATURE:
> +       case USB_REQ_SET_FEATURE:
> +               /* Requests with no data phase, status phase from udc */
> +               if ((udc->setup.bRequestType & USB_TYPE_MASK)
> +                               != USB_TYPE_STANDARD)
> +                       break;
> +               xudc_set_clear_feature(udc);
> +               return;
> +       default:
> +               break;
> +       }
> +
> +       spin_unlock(&udc->lock);
> +       if (udc->driver->setup(&udc->gadget, &setup) < 0)
> +               xudc_ep0_stall(udc);
> +       spin_lock(&udc->lock);
> +}
> +
> +/**
> + * xudc_ep0_out - Processes the endpoint 0 OUT token.
> + * @udc: pointer to the usb device controller structure.
> + */
> +static void xudc_ep0_out(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0 = &udc->ep[0];
> +       struct xusb_req *req;
> +       u8 *ep0rambase;
> +       unsigned int bytes_to_rx;
> +       void *buffer;
> +
> +       req = list_first_entry(&ep0->queue, struct xusb_req, queue);
> +
> +       switch (udc->setupseqrx) {
> +       case STATUS_PHASE:
> +               /*
> +                * This resets both state machines for the next
> +                * Setup packet.
> +                */
> +               udc->setupseqrx = SETUP_PHASE;
> +               udc->setupseqtx = SETUP_PHASE;
> +               req->usb_req.actual = req->usb_req.length;
> +               xudc_done(ep0, req, 0);
> +               break;
> +       case DATA_PHASE:
> +               bytes_to_rx = udc->read_fn(udc->base_address +
> +                               XUSB_EP_BUF0COUNT_OFFSET);
> +               /* Copy the data to be received from the DPRAM. */
> +               ep0rambase = (u8 __force *) (udc->base_address +
> +                               (ep0->rambase << 2));
> +
> +               buffer = req->usb_req.buf + req->usb_req.actual;
> +               req->usb_req.actual = req->usb_req.actual + bytes_to_rx;
> +               memcpy(buffer, (void *)ep0rambase, bytes_to_rx);
> +
> +               if (req->usb_req.length == req->usb_req.actual) {
> +                       /* Data transfer completed get ready for Status stage */
> +                       xudc_wrstatus(udc);
> +               } else {
> +                       /* Enable EP0 buffer to receive data */
> +                       udc->write_fn(udc->base_address,
> +                                       XUSB_EP_BUF0COUNT_OFFSET, 0);
> +                       udc->write_fn(udc->base_address,
> +                                       XUSB_BUFFREADY_OFFSET, 1);
> +               }
> +               break;
> +       default:
> +               break;
> +       }
> +}
> +
> +/**
> + * xudc_ep0_in - Processes the endpoint 0 IN token.
> + * @udc: pointer to the usb device controller structure.
> + */
> +static void xudc_ep0_in(struct xusb_udc *udc)
> +{
> +       struct xusb_ep *ep0 = &udc->ep[0];
> +       struct xusb_req *req;
> +       unsigned int bytes_to_tx;
> +       void *buffer;
> +       u32 epcfgreg;
> +       u16 count = 0;
> +       u16 length;
> +       u8 *ep0rambase;
> +       u8 test_mode = udc->setup.wIndex >> 8;
> +
> +       req = list_first_entry(&ep0->queue, struct xusb_req, queue);
> +       bytes_to_tx = req->usb_req.length - req->usb_req.actual;
> +
> +       switch (udc->setupseqtx) {
> +       case STATUS_PHASE:
> +               switch (udc->setup.bRequest) {
> +               case USB_REQ_SET_ADDRESS:
> +                       /* Set the address of the device.*/
> +                       udc->write_fn(udc->base_address,
> +                                       XUSB_ADDRESS_OFFSET,
> +                                       udc->setup.wValue);
> +                       break;
> +               case USB_REQ_SET_FEATURE:
> +                       if (udc->setup.bRequestType ==
> +                                       USB_RECIP_DEVICE) {
> +                               if (udc->setup.wValue ==
> +                                               USB_DEVICE_TEST_MODE)
> +                                       udc->write_fn(udc->base_address,
> +                                                       XUSB_TESTMODE_OFFSET,
> +                                                       test_mode);
> +                       }
> +                       break;
> +               }
> +               req->usb_req.actual = req->usb_req.length;
> +               xudc_done(ep0, req, 0);
> +               break;
> +       case DATA_PHASE:
> +               if (!bytes_to_tx) {
> +                       /*
> +                        * We're done with data transfer, next
> +                        * will be zero length OUT with data toggle of
> +                        * 1. Setup data_toggle.
> +                        */
> +                       epcfgreg = udc->read_fn(udc->base_address +
> +                                       ep0->offset);
> +                       epcfgreg |= XUSB_EP_CFG_DATA_TOGGLE_MASK;
> +                       udc->write_fn(udc->base_address, ep0->offset, epcfgreg);
> +                       udc->setupseqtx = STATUS_PHASE;
> +               } else {
> +                       length = count = min_t(u32, bytes_to_tx,
> +                                               EP0_MAX_PACKET);
> +                       /* Copy the data to be transmitted into the DPRAM. */
> +                       ep0rambase = (u8 __force *) (udc->base_address +
> +                                       (ep0->rambase << 2));
> +
> +                       buffer = req->usb_req.buf + req->usb_req.actual;
> +                       req->usb_req.actual = req->usb_req.actual + length;
> +                       memcpy((void *)ep0rambase, buffer, length);
> +               }
> +               udc->write_fn(udc->base_address, XUSB_EP_BUF0COUNT_OFFSET,
> +                               count);
> +               udc->write_fn(udc->base_address, XUSB_BUFFREADY_OFFSET, 1);
> +               break;
> +       default:
> +               break;
> +       }
> +}
> +
> +/**
> + * xudc_ctrl_ep_handler - Endpoint 0 interrupt handler.
> + * @udc: pointer to the udc structure.
> + * @intrstatus:        It's the mask value for the interrupt sources on endpoint 0.
> + *
> + * Processes the commands received during enumeration phase.
> + */
> +static void xudc_ctrl_ep_handler(struct xusb_udc *udc, u32 intrstatus)
> +{
> +
> +       if (intrstatus & XUSB_STATUS_SETUP_PACKET_MASK) {
> +               xudc_handle_setup(udc);
> +       } else {
> +               if (intrstatus & XUSB_STATUS_FIFO_BUFF_RDY_MASK)
> +                       xudc_ep0_out(udc);
> +               else if (intrstatus & XUSB_STATUS_FIFO_BUFF_FREE_MASK)
> +                       xudc_ep0_in(udc);
> +       }
> +}
> +
> +/**
> + * xudc_nonctrl_ep_handler - Non control endpoint interrupt handler.
> + * @udc: pointer to the udc structure.
> + * @epnum: End point number for which the interrupt is to be processed
> + * @intrstatus:        mask value for interrupt sources of endpoints other
> + *             than endpoint 0.
> + *
> + * Processes the buffer completion interrupts.
> + */
> +static void xudc_nonctrl_ep_handler(struct xusb_udc *udc, u8 epnum,
> +                                       u32 intrstatus)
> +{
> +
> +       struct xusb_req *req;
> +       struct xusb_ep *ep;
> +
> +       ep = &udc->ep[epnum];
> +       /* Process the End point interrupts.*/
> +       if (intrstatus & (XUSB_STATUS_EP0_BUFF1_COMP_MASK << epnum))
> +               ep->buffer0ready = 0;
> +       if (intrstatus & (XUSB_STATUS_EP0_BUFF2_COMP_MASK << epnum))
> +               ep->buffer1ready = 0;
> +
> +       if (list_empty(&ep->queue))
> +               return;
> +
> +       req = list_first_entry(&ep->queue, struct xusb_req, queue);
> +
> +       if (ep->is_in)
> +               xudc_write_fifo(ep, req);
> +       else
> +               xudc_read_fifo(ep, req);
> +}
> +
> +/**
> + * xudc_irq - The main interrupt handler.
> + * @irq: The interrupt number.
> + * @_udc: pointer to the usb device controller structure.
> + *
> + * Return: IRQ_HANDLED after the interrupt is handled.
> + */
> +static irqreturn_t xudc_irq(int irq, void *_udc)
> +{
> +       struct xusb_udc *udc = _udc;
> +       u32 intrstatus;
> +       u32 ier;
> +       u8 index;
> +       u32 bufintr;
> +       unsigned long flags;
> +
> +       spin_lock_irqsave(&udc->lock, flags);
> +
> +       /*
> +        * Event interrupts are level sensitive hence first disable
> +        * IER, read ISR and figure out active interrupts.
> +        */
> +       ier = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +       ier &= ~XUSB_STATUS_INTR_EVENT_MASK;
> +       udc->write_fn(udc->base_address, XUSB_IER_OFFSET, ier);
> +
> +       /* Read the Interrupt Status Register.*/
> +       intrstatus = udc->read_fn(udc->base_address + XUSB_STATUS_OFFSET);
> +
> +       /* Call the handler for the event interrupt.*/
> +       if (intrstatus & XUSB_STATUS_INTR_EVENT_MASK) {
> +               /*
> +                * Check if there is any action to be done for :
> +                * - USB Reset received {XUSB_STATUS_RESET_MASK}
> +                * - USB Suspend received {XUSB_STATUS_SUSPEND_MASK}
> +                * - USB Resume received {XUSB_STATUS_RESUME_MASK}
> +                * - USB Disconnect received {XUSB_STATUS_DISCONNECT_MASK}
> +                */
> +               xudc_startup_handler(udc, intrstatus);
> +       }
> +
> +       /* Check the buffer completion interrupts */
> +       if (intrstatus & XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK) {
> +               /* Enable Reset, Suspend, Resume and Disconnect  */
> +               ier = udc->read_fn(udc->base_address + XUSB_IER_OFFSET);
> +               ier |= XUSB_STATUS_INTR_EVENT_MASK;
> +               udc->write_fn(udc->base_address, XUSB_IER_OFFSET, ier);
> +
> +               if (intrstatus & XUSB_STATUS_EP0_BUFF1_COMP_MASK)
> +                       xudc_ctrl_ep_handler(udc, intrstatus);
> +
> +               for (index = 1; index < 8; index++) {
> +                       bufintr = ((intrstatus &
> +                                       (XUSB_STATUS_EP1_BUFF1_COMP_MASK <<
> +                                                       (index - 1))) ||
> +                                  (intrstatus &
> +                                       (XUSB_STATUS_EP1_BUFF2_COMP_MASK <<
> +                                                       (index - 1))));
> +                       if (bufintr) {
> +                               xudc_nonctrl_ep_handler(udc, index,
> +                                               intrstatus);
> +                       }
> +               }
> +       }
> +
> +       spin_unlock_irqrestore(&udc->lock, flags);
> +       return IRQ_HANDLED;
> +}
> +
> +/**
> + * xudc_probe - The device probe function for driver initialization.
> + * @pdev: pointer to the platform device structure.
> + *
> + * Return: 0 for success and error value on failure
> + */
> +static int xudc_probe(struct platform_device *pdev)
> +{
> +       struct device_node *np = pdev->dev.of_node;
> +       struct resource *res;
> +       struct xusb_udc *udc;
> +       struct xusb_ep *ep0;
> +       int irq;
> +       int ret;
> +       u32 ier;
> +       u8 *buff;
> +
> +       udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL);
> +       if (!udc)
> +               return -ENOMEM;
> +
> +       /* Map the registers */
> +       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +       udc->base_address = devm_ioremap_resource(&pdev->dev, res);
> +       if (!udc->base_address)
> +               return -ENOMEM;
> +
> +       irq = platform_get_irq(pdev, 0);
> +       if (irq < 0) {
> +               dev_err(&pdev->dev, "unable to get irq\n");
> +               return irq;
> +       }
> +       ret = devm_request_irq(&pdev->dev, irq, xudc_irq, 0,
> +                               dev_name(&pdev->dev), udc);
> +       if (ret < 0) {
> +               dev_dbg(&pdev->dev, "unable to request irq %d", irq);
> +               goto fail;
> +       }
> +
> +       udc->dma_enabled = of_property_read_bool(np, "xlnx,has-builtin-dma");
> +
> +       /* Setup gadget structure */
> +       udc->gadget.ops = &xusb_udc_ops;
> +       udc->gadget.max_speed = USB_SPEED_HIGH;
> +       udc->gadget.speed = USB_SPEED_UNKNOWN;
> +       udc->gadget.ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO].ep_usb;
> +       udc->gadget.name = driver_name;
> +
> +       spin_lock_init(&udc->lock);
> +
> +       /* Check for IP endianness */
> +       udc->write_fn = xudc_write32_be;
> +       udc->read_fn = xudc_read32_be;
> +       udc->write_fn(udc->base_address, XUSB_TESTMODE_OFFSET, TEST_J);
> +       if ((udc->read_fn(udc->base_address + XUSB_TESTMODE_OFFSET))
> +                       != TEST_J) {
> +               udc->write_fn = xudc_write32;
> +               udc->read_fn = xudc_read32;
> +       }
> +       udc->write_fn(udc->base_address, XUSB_TESTMODE_OFFSET, 0);
> +
> +       xudc_eps_init(udc);
> +
> +       ep0 = &udc->ep[0];
> +       /* Create a dummy request for GET_STATUS, SET_ADDRESS */
> +       udc->req = container_of(xudc_ep_alloc_request(&ep0->ep_usb, GFP_KERNEL),
> +                                       struct xusb_req, usb_req);
> +       if (!udc->req) {
> +               ret = -ENOMEM;
> +               goto fail;
> +       }
> +
> +       /* buffer for data of get_status request */
> +       buff = kzalloc(2, GFP_KERNEL);
> +       if (buff == NULL) {
> +               ret = -ENOMEM;
> +               goto fail;
> +       }
> +       /* Dummy request ready, free this in remove */
> +       udc->req->usb_req.buf = buff;
> +
> +       /* Set device address to 0.*/
> +       udc->write_fn(udc->base_address, XUSB_ADDRESS_OFFSET, 0);
> +
> +       ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
> +       if (ret)
> +               goto fail;
> +
> +       udc->dev = &udc->gadget.dev;
> +
> +       /* Enable the interrupts.*/
> +       ier = XUSB_STATUS_GLOBAL_INTR_MASK | XUSB_STATUS_INTR_EVENT_MASK |
> +               XUSB_STATUS_FIFO_BUFF_RDY_MASK |
> +               XUSB_STATUS_FIFO_BUFF_FREE_MASK |
> +               XUSB_STATUS_SETUP_PACKET_MASK |
> +               XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK;
> +
> +       udc->write_fn(udc->base_address, XUSB_IER_OFFSET, ier);
> +
> +       platform_set_drvdata(pdev, udc);
> +
> +       dev_dbg(&pdev->dev, "%s at 0x%08X mapped to 0x%08X %s\n",
> +               driver_name, (u32)res->start,
> +               (u32 __force)udc->base_address,
> +               udc->dma_enabled ? "with DMA" : "without DMA");
> +
> +       return 0;
> +fail:
> +       dev_err(&pdev->dev, "probe failed, %d\n", ret);
> +       return ret;
> +}
> +
> +/**
> + * xudc_remove - Releases the resources allocated during the initialization.
> + * @pdev: pointer to the platform device structure.
> + *
> + * Return: 0 always
> + */
> +static int xudc_remove(struct platform_device *pdev)
> +{
> +       struct xusb_udc *udc = platform_get_drvdata(pdev);
> +       void *buf = udc->req->usb_req.buf;
> +
> +       usb_del_gadget_udc(&udc->gadget);
> +
> +       /* free memory allocated for dummy request buffer */
> +       kfree(buf);
> +       /* free memory allocated for dummy request */
> +       kfree(udc->req);
> +
> +       return 0;
> +}
> +
> +/* Match table for of_platform binding */
> +static const struct of_device_id usb_of_match[] = {
> +       { .compatible = "xlnx,xps-usb2-device-4.00.a", },
> +       { /* end of list */ },
> +};
> +MODULE_DEVICE_TABLE(of, usb_of_match);
> +
> +static struct platform_driver xudc_driver = {
> +       .driver = {
> +               .name = driver_name,
> +               .owner = THIS_MODULE,
> +               .of_match_table = usb_of_match,
> +       },
> +       .probe = xudc_probe,
> +       .remove = xudc_remove,
> +};
> +
> +module_platform_driver(xudc_driver);
> +
> +MODULE_DESCRIPTION("Xilinx udc driver");
> +MODULE_AUTHOR("Xilinx, Inc");
> +MODULE_LICENSE("GPL");
> --
> 1.7.4
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Device Tree Compilter]     [Device Tree Spec]     [Linux Driver Backports]     [Video for Linux]     [Linux USB Devel]     [Linux PCI Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Yosemite Backpacking]
  Powered by Linux