Re: [PATCH v4] usb: gadget: Add UDC driver for Aeroflex Gaisler GRUSBDC

From: Robert Baldyga
Date: Thu Dec 19 2013 - 10:31:31 EST

Next message: Levente Kurusa: "Re: [PATCH 21/38] workqueue: add missing put_device call"
Previous message: Sebastian Andrzej Siewior: "[PATCH 5/5] mfd: input: iio: ti_amm335x: Rework TSC/ADC synchronization"
In reply to: Andreas Larsson: "[PATCH v4] usb: gadget: Add UDC driver for Aeroflex Gaisler GRUSBDC"
Next in thread: Andreas Larsson: "Re: [PATCH v4] usb: gadget: Add UDC driver for Aeroflex Gaisler GRUSBDC"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

Hi Andreas,

According to changes in gadget API, which I did in this patch
http://permalink.gmane.org/gmane.linux.usb.general/100108 you should
initialize endpoints with ep_set_maxpacket_limit() function.

I described needed changes in your code (in gr_ep_init() function).

Best regards,
Robert Baldyga,
Samsung R&D Institute Poland

On 12/19/2013 01:40 PM, Andreas Larsson wrote:
> This adds an UDC driver for GRUSBDC USB Device Controller cores available in the
> GRLIB VHDL IP core library. The driver only supports DMA mode.
>
> Signed-off-by: Andreas Larsson <andreas@xxxxxxxxxxx>
> ---
>
> Differences since v1:
> - Use hexprint for debug printoutes instead of homemade equivalent
> - Use the dev_* printk variants over the board
> - Get rid of unnecessary casts and includes
> - Use USB_STATE_NOTATTACHED instead of USB_STATE_ATTACHED for clarity
> - Get rid of commented out VERBOSE_DEBUG definition
> - Do not devm-allocate any requests
> - Get rid of unnecessary resqueduling of the workqueue handler
> - Make sure that gadget setup function is called with interrupts disabled
> Differences since v2:
> - Fixed an error printout
> - Got rid of the work queue in favor of threaded interrupts
> Differences since v3:
> - Disable interrupts when locking spinlocks instead of using
> local_irq_save deeper within critical section
>
> drivers/usb/gadget/Kconfig | 7 +
> drivers/usb/gadget/Makefile | 1 +
> drivers/usb/gadget/gr_udc.c | 2226 +++++++++++++++++++++++++++++++++++++++++++
> drivers/usb/gadget/gr_udc.h | 220 +++++
> 4 files changed, 2454 insertions(+)
> create mode 100644 drivers/usb/gadget/gr_udc.c
> create mode 100644 drivers/usb/gadget/gr_udc.h
>
> diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
> index a91e642..390dbea 100644
> --- a/drivers/usb/gadget/Kconfig
> +++ b/drivers/usb/gadget/Kconfig
> @@ -216,6 +216,13 @@ config USB_FOTG210_UDC
> Say "y" to link the driver statically, or "m" to build a
> dynamically linked module called "fotg210_udc".
>
> +config USB_GR_UDC
> + tristate "Aeroflex Gaisler GRUSBDC USB Peripheral Controller Driver"
> + depends on OF && HAS_DMA
> + help
> + Select this to support Aeroflex Gaisler GRUSBDC cores from the GRLIB
> + VHDL IP core library.
> +
> config USB_OMAP
> tristate "OMAP USB Device Controller"
> depends on ARCH_OMAP1
> diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
> index f1af396..94d6beb 100644
> --- a/drivers/usb/gadget/Makefile
> +++ b/drivers/usb/gadget/Makefile
> @@ -35,6 +35,7 @@ mv_udc-y := mv_udc_core.o
> 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
>
> # USB Functions
> usb_f_acm-y := f_acm.o
> diff --git a/drivers/usb/gadget/gr_udc.c b/drivers/usb/gadget/gr_udc.c
> new file mode 100644
> index 0000000..671bcc8
> --- /dev/null
> +++ b/drivers/usb/gadget/gr_udc.c
> @@ -0,0 +1,2226 @@
> +/*
> + * USB Peripheral Controller driver for Aeroflex Gaisler GRUSBDC.
> + *
> + * 2013 (c) Aeroflex Gaisler AB
> + *
> + * This driver supports GRUSBDC USB Device Controller cores available in the
> + * GRLIB VHDL IP core library.
> + *
> + * Full documentation of the GRUSBDC core can be found here:
> + * http://www.gaisler.com/products/grlib/grip.pdf
> + *
> + * 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.
> + *
> + * Contributors:
> + * - Andreas Larsson <andreas@xxxxxxxxxxx>
> + * - Marko Isomaki
> + */
> +
> +/*
> + * A GRUSBDC core can have up to 16 IN endpoints and 16 OUT endpoints each
> + * individually configurable to any of the four USB transfer types. This driver
> + * only supports cores in DMA mode.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/spinlock.h>
> +#include <linux/errno.h>
> +#include <linux/init.h>
> +#include <linux/list.h>
> +#include <linux/interrupt.h>
> +#include <linux/device.h>
> +#include <linux/usb/ch9.h>
> +#include <linux/usb/gadget.h>
> +#include <linux/dma-mapping.h>
> +#include <linux/dmapool.h>
> +#include <linux/debugfs.h>
> +#include <linux/seq_file.h>
> +#include <linux/of_platform.h>
> +#include <linux/of_irq.h>
> +#include <linux/of_address.h>
> +
> +#include <asm/byteorder.h>
> +
> +#include "gr_udc.h"
> +
> +#define DRIVER_NAME "gr_udc"
> +#define DRIVER_DESC "Aeroflex Gaisler GRUSBDC USB Peripheral Controller"
> +
> +static const char driver_name[] = DRIVER_NAME;
> +static const char driver_desc[] = DRIVER_DESC;
> +
> +#define gr_read32(x) (ioread32be((x)))
> +#define gr_write32(x, v) (iowrite32be((v), (x)))
> +
> +/* USB speed and corresponding string calculated from status register value */
> +#define GR_SPEED(status) \
> + ((status & GR_STATUS_SP) ? USB_SPEED_FULL : USB_SPEED_HIGH)
> +#define GR_SPEED_STR(status) usb_speed_string(GR_SPEED(status))
> +
> +/* Size of hardware buffer calculated from epctrl register value */
> +#define GR_BUFFER_SIZE(epctrl) \
> + ((((epctrl) & GR_EPCTRL_BUFSZ_MASK) >> GR_EPCTRL_BUFSZ_POS) * \
> + GR_EPCTRL_BUFSZ_SCALER)
> +
> +/* ---------------------------------------------------------------------- */
> +/* Debug printout functionality */
> +
> +static const char * const gr_modestring[] = {"control", "iso", "bulk", "int"};
> +
> +static const char *gr_ep0state_string(enum gr_ep0state state)
> +{
> + static const char *const names[] = {
> + [GR_EP0_DISCONNECT] = "disconnect",
> + [GR_EP0_SETUP] = "setup",
> + [GR_EP0_IDATA] = "idata",
> + [GR_EP0_ODATA] = "odata",
> + [GR_EP0_ISTATUS] = "istatus",
> + [GR_EP0_OSTATUS] = "ostatus",
> + [GR_EP0_STALL] = "stall",
> + [GR_EP0_SUSPEND] = "suspend",
> + };
> +
> + if (state < 0 || state >= ARRAY_SIZE(names))
> + return "UNKNOWN";
> +
> + return names[state];
> +}
> +
> +#ifdef VERBOSE_DEBUG
> +
> +static void gr_dbgprint_request(const char *str, struct gr_ep *ep,
> + struct gr_request *req)
> +{
> + int buflen = ep->is_in ? req->req.length : req->req.actual;
> + int rowlen = 32;
> + int plen = min(rowlen, buflen);
> +
> + dev_dbg(ep->dev->dev, "%s: 0x%p, %d bytes data%s:\n", str, req, buflen,
> + (buflen > plen ? " (truncated)" : ""));
> + print_hex_dump_debug(" ", DUMP_PREFIX_NONE,
> + rowlen, 4, req->req.buf, plen, false);
> +}
> +
> +static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
> + u16 value, u16 index, u16 length)
> +{
> + dev_vdbg(dev->dev, "REQ: %02x.%02x v%04x i%04x l%04x\n",
> + type, request, value, index, length);
> +}
> +#else /* !VERBOSE_DEBUG */
> +
> +static void gr_dbgprint_request(const char *str, struct gr_ep *ep,
> + struct gr_request *req) {}
> +
> +static void gr_dbgprint_devreq(struct gr_udc *dev, u8 type, u8 request,
> + u16 value, u16 index, u16 length) {}
> +
> +#endif /* VERBOSE_DEBUG */
> +
> +/* ---------------------------------------------------------------------- */
> +/* Debugfs functionality */
> +
> +#ifdef CONFIG_USB_GADGET_DEBUG_FS
> +
> +static void gr_seq_ep_show(struct seq_file *seq, struct gr_ep *ep)
> +{
> + u32 epctrl = gr_read32(&ep->regs->epctrl);
> + u32 epstat = gr_read32(&ep->regs->epstat);
> + int mode = (epctrl & GR_EPCTRL_TT_MASK) >> GR_EPCTRL_TT_POS;
> + struct gr_request *req;
> +
> + seq_printf(seq, "%s:\n", ep->ep.name);
> + seq_printf(seq, " mode = %s\n", gr_modestring[mode]);
> + seq_printf(seq, " halted: %d\n", !!(epctrl & GR_EPCTRL_EH));
> + seq_printf(seq, " disabled: %d\n", !!(epctrl & GR_EPCTRL_ED));
> + seq_printf(seq, " valid: %d\n", !!(epctrl & GR_EPCTRL_EV));
> + seq_printf(seq, " dma_start = %d\n", ep->dma_start);
> + seq_printf(seq, " stopped = %d\n", ep->stopped);
> + seq_printf(seq, " wedged = %d\n", ep->wedged);
> + seq_printf(seq, " callback = %d\n", ep->callback);
> + seq_printf(seq, " maxpacket = %d\n", ep->ep.maxpacket);
> + seq_printf(seq, " bytes_per_buffer = %d\n", ep->bytes_per_buffer);
> + if (mode == 1 || mode == 3)
> + seq_printf(seq, " nt = %d\n",
> + (epctrl & GR_EPCTRL_NT_MASK) >> GR_EPCTRL_NT_POS);
> +
> + seq_printf(seq, " Buffer 0: %s %s%d\n",
> + epstat & GR_EPSTAT_B0 ? "valid" : "invalid",
> + epstat & GR_EPSTAT_BS ? " " : "selected ",
> + (epstat & GR_EPSTAT_B0CNT_MASK) >> GR_EPSTAT_B0CNT_POS);
> + seq_printf(seq, " Buffer 1: %s %s%d\n",
> + epstat & GR_EPSTAT_B1 ? "valid" : "invalid",
> + epstat & GR_EPSTAT_BS ? "selected " : " ",
> + (epstat & GR_EPSTAT_B1CNT_MASK) >> GR_EPSTAT_B1CNT_POS);
> +
> + if (list_empty(&ep->queue)) {
> + seq_puts(seq, " Queue: empty\n\n");
> + return;
> + }
> +
> + seq_puts(seq, " Queue:\n");
> + list_for_each_entry(req, &ep->queue, queue) {
> + struct gr_dma_desc *desc;
> + struct gr_dma_desc *next;
> +
> + seq_printf(seq, " 0x%p: 0x%p %d %d\n", req,
> + &req->req.buf, req->req.actual, req->req.length);
> +
> + next = req->first_desc;
> + do {
> + desc = next;
> + next = desc->next_desc;
> + seq_printf(seq, " %c 0x%p (0x%08x): 0x%05x 0x%08x\n",
> + desc == req->curr_desc ? 'c' : ' ',
> + desc, desc->paddr, desc->ctrl, desc->data);
> + } while (desc != req->last_desc);
> + }
> + seq_puts(seq, "\n");
> +}
> +
> +
> +static int gr_seq_show(struct seq_file *seq, void *v)
> +{
> + struct gr_udc *dev = seq->private;
> + u32 control = gr_read32(&dev->regs->control);
> + u32 status = gr_read32(&dev->regs->status);
> + struct gr_ep *ep;
> +
> + seq_printf(seq, "usb state = %s\n",
> + usb_state_string(dev->gadget.state));
> + seq_printf(seq, "address = %d\n",
> + (control & GR_CONTROL_UA_MASK) >> GR_CONTROL_UA_POS);
> + seq_printf(seq, "speed = %s\n", GR_SPEED_STR(status));
> + seq_printf(seq, "ep0state = %s\n", gr_ep0state_string(dev->ep0state));
> + seq_printf(seq, "irq_enabled = %d\n", dev->irq_enabled);
> + seq_printf(seq, "remote_wakeup = %d\n", dev->remote_wakeup);
> + seq_printf(seq, "test_mode = %d\n", dev->test_mode);
> + seq_puts(seq, "\n");
> +
> + list_for_each_entry(ep, &dev->ep_list, ep_list)
> + gr_seq_ep_show(seq, ep);
> +
> + return 0;
> +}
> +
> +static int gr_dfs_open(struct inode *inode, struct file *file)
> +{
> + return single_open(file, gr_seq_show, inode->i_private);
> +}
> +
> +static const struct file_operations gr_dfs_fops = {
> + .owner = THIS_MODULE,
> + .open = gr_dfs_open,
> + .read = seq_read,
> + .llseek = seq_lseek,
> + .release = single_release,
> +};
> +
> +static void gr_dfs_create(struct gr_udc *dev)
> +{
> + const char *name = "gr_udc_state";
> +
> + dev->dfs_root = debugfs_create_dir(dev_name(dev->dev), NULL);
> + if (IS_ERR(dev->dfs_root)) {
> + dev_err(dev->dev, "Failed to create debugfs directory\n");
> + return;
> + }
> + dev->dfs_state = debugfs_create_file(name, 0444, dev->dfs_root,
> + dev, &gr_dfs_fops);
> + if (IS_ERR(dev->dfs_state))
> + dev_err(dev->dev, "Failed to create debugfs file %s\n", name);
> +}
> +
> +static void gr_dfs_delete(struct gr_udc *dev)
> +{
> + /* Handles NULL and ERR pointers internally */
> + debugfs_remove(dev->dfs_state);
> + debugfs_remove(dev->dfs_root);
> +}
> +
> +#else /* !CONFIG_USB_GADGET_DEBUG_FS */
> +
> +static void gr_dfs_create(struct gr_udc *dev) {}
> +static void gr_dfs_delete(struct gr_udc *dev) {}
> +
> +#endif /* CONFIG_USB_GADGET_DEBUG_FS */
> +
> +/* ---------------------------------------------------------------------- */
> +/* DMA and request handling */
> +
> +/* Allocates a new struct gr_dma_desc, sets paddr and zeroes the rest */
> +static struct gr_dma_desc *gr_alloc_dma_desc(struct gr_ep *ep, gfp_t gfp_flags)
> +{
> + dma_addr_t paddr;
> + struct gr_dma_desc *dma_desc;
> +
> + dma_desc = dma_pool_alloc(ep->dev->desc_pool, gfp_flags, &paddr);
> + if (!dma_desc) {
> + dev_err(ep->dev->dev, "Could not allocate from DMA pool\n");
> + return NULL;
> + }
> +
> + memset(dma_desc, 0, sizeof(*dma_desc));
> + dma_desc->paddr = paddr;
> +
> + return dma_desc;
> +}
> +
> +static inline void gr_free_dma_desc(struct gr_udc *dev,
> + struct gr_dma_desc *desc)
> +{
> + dma_pool_free(dev->desc_pool, desc, (dma_addr_t)desc->paddr);
> +}
> +
> +/* Frees the chain of struct gr_dma_desc for the given request */
> +static void gr_free_dma_desc_chain(struct gr_udc *dev, struct gr_request *req)
> +{
> + struct gr_dma_desc *desc;
> + struct gr_dma_desc *next;
> +
> + next = req->first_desc;
> + if (!next)
> + return;
> +
> + do {
> + desc = next;
> + next = desc->next_desc;
> + gr_free_dma_desc(dev, desc);
> + } while (desc != req->last_desc);
> +
> + req->first_desc = NULL;
> + req->curr_desc = NULL;
> + req->last_desc = NULL;
> +}
> +
> +static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req);
> +
> +/*
> + * Frees allocated resources and calls the appropriate completion function/setup
> + * package handler for a finished request.
> + *
> + * Must be called with dev->lock held and irqs disabled.
> + */
> +static void gr_finish_request(struct gr_ep *ep, struct gr_request *req,
> + int status)
> +{
> + struct gr_udc *dev;
> +
> + list_del_init(&req->queue);
> +
> + if (likely(req->req.status == -EINPROGRESS))
> + req->req.status = status;
> + else
> + status = req->req.status;
> +
> + dev = ep->dev;
> + usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
> + gr_free_dma_desc_chain(dev, req);
> +
> + if (ep->is_in) /* For OUT, actual gets updated bit by bit */
> + req->req.actual = req->req.length;
> +
> + if (!status) {
> + if (ep->is_in)
> + gr_dbgprint_request("SENT", ep, req);
> + else
> + gr_dbgprint_request("RECV", ep, req);
> + }
> +
> + /* Prevent changes to ep->queue during callback */
> + ep->callback = 1;
> + if (req == dev->ep0reqo && !status) {
> + if (req->setup)
> + gr_ep0_setup(dev, req);
> + else
> + dev_err(dev->dev,
> + "Unexpected non setup packet on ep0in\n");
> + } else if (req->req.complete) {
> + spin_unlock(&dev->lock);
> +
> + req->req.complete(&ep->ep, &req->req);
> +
> + spin_lock(&dev->lock);
> + }
> + ep->callback = 0;
> +}
> +
> +static struct usb_request *gr_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
> +{
> + struct gr_request *req;
> +
> + req = kzalloc(sizeof(*req), gfp_flags);
> + if (!req)
> + return NULL;
> +
> + INIT_LIST_HEAD(&req->queue);
> +
> + return &req->req;
> +}
> +
> +/*
> + * Starts DMA for endpoint ep if there are requests in the queue.
> + *
> + * Must be called with dev->lock held and with !ep->stopped.
> + */
> +static void gr_start_dma(struct gr_ep *ep)
> +{
> + struct gr_request *req;
> + u32 dmactrl;
> +
> + if (list_empty(&ep->queue)) {
> + ep->dma_start = 0;
> + return;
> + }
> +
> + req = list_first_entry(&ep->queue, struct gr_request, queue);
> +
> + /* A descriptor should already have been allocated */
> + BUG_ON(!req->curr_desc);
> +
> + wmb(); /* Make sure all is settled before handing it over to DMA */
> +
> + /* Set the descriptor pointer in the hardware */
> + gr_write32(&ep->regs->dmaaddr, req->curr_desc->paddr);
> +
> + /* Announce available descriptors */
> + dmactrl = gr_read32(&ep->regs->dmactrl);
> + gr_write32(&ep->regs->dmactrl, dmactrl | GR_DMACTRL_DA);
> +
> + ep->dma_start = 1;
> +}
> +
> +/*
> + * Finishes the first request in the ep's queue and, if available, starts the
> + * next request in queue.
> + *
> + * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
> + */
> +static void gr_dma_advance(struct gr_ep *ep, int status)
> +{
> + struct gr_request *req;
> +
> + req = list_first_entry(&ep->queue, struct gr_request, queue);
> + gr_finish_request(ep, req, status);
> + gr_start_dma(ep); /* Regardless of ep->dma_start */
> +}
> +
> +/*
> + * Abort DMA for an endpoint. Sets the abort DMA bit which causes an ongoing DMA
> + * transfer to be canceled and clears GR_DMACTRL_DA.
> + *
> + * Must be called with dev->lock held.
> + */
> +static void gr_abort_dma(struct gr_ep *ep)
> +{
> + u32 dmactrl;
> +
> + dmactrl = gr_read32(&ep->regs->dmactrl);
> + gr_write32(&ep->regs->dmactrl, dmactrl | GR_DMACTRL_AD);
> +}
> +
> +/*
> + * Allocates and sets up a struct gr_dma_desc and putting it on the descriptor
> + * chain.
> + *
> + * Size is not used for OUT endpoints. Hardware can not be instructed to handle
> + * smaller buffer than MAXPL in the OUT direction.
> + */
> +static int gr_add_dma_desc(struct gr_ep *ep, struct gr_request *req,
> + dma_addr_t data, unsigned size, gfp_t gfp_flags)
> +{
> + struct gr_dma_desc *desc;
> +
> + desc = gr_alloc_dma_desc(ep, gfp_flags);
> + if (!desc)
> + return -ENOMEM;
> +
> + desc->data = data;
> + if (ep->is_in)
> + desc->ctrl =
> + (GR_DESC_IN_CTRL_LEN_MASK & size) | GR_DESC_IN_CTRL_EN;
> + else
> + desc->ctrl = GR_DESC_OUT_CTRL_IE;
> +
> + if (!req->first_desc) {
> + req->first_desc = desc;
> + req->curr_desc = desc;
> + } else {
> + req->last_desc->next_desc = desc;
> + req->last_desc->next = desc->paddr;
> + req->last_desc->ctrl |= GR_DESC_OUT_CTRL_NX;
> + }
> + req->last_desc = desc;
> +
> + return 0;
> +}
> +
> +/*
> + * Sets up a chain of struct gr_dma_descriptors pointing to buffers that
> + * together covers req->req.length bytes of the buffer at DMA address
> + * req->req.dma for the OUT direction.
> + *
> + * The first descriptor in the chain is enabled, the rest disabled. The
> + * interrupt handler will later enable them one by one when needed so we can
> + * find out when the transfer is finished. For OUT endpoints, all descriptors
> + * therefore generate interrutps.
> + */
> +static int gr_setup_out_desc_list(struct gr_ep *ep, struct gr_request *req,
> + gfp_t gfp_flags)
> +{
> + u16 bytes_left; /* Bytes left to provide descriptors for */
> + u16 bytes_used; /* Bytes accommodated for */
> + int ret = 0;
> +
> + req->first_desc = NULL; /* Signals that no allocation is done yet */
> + bytes_left = req->req.length;
> + bytes_used = 0;
> + while (bytes_left > 0) {
> + dma_addr_t start = req->req.dma + bytes_used;
> + u16 size = min(bytes_left, ep->bytes_per_buffer);
> +
> + /* Should not happen however - gr_queue stops such lengths */
> + if (size < ep->bytes_per_buffer)
> + dev_warn(ep->dev->dev,
> + "Buffer overrun risk: %u < %u bytes/buffer\n",
> + size, ep->bytes_per_buffer);
> +
> + ret = gr_add_dma_desc(ep, req, start, size, gfp_flags);
> + if (ret)
> + goto alloc_err;
> +
> + bytes_left -= size;
> + bytes_used += size;
> + }
> +
> + req->first_desc->ctrl |= GR_DESC_OUT_CTRL_EN;
> +
> + return 0;
> +
> +alloc_err:
> + gr_free_dma_desc_chain(ep->dev, req);
> +
> + return ret;
> +}
> +
> +/*
> + * Sets up a chain of struct gr_dma_descriptors pointing to buffers that
> + * together covers req->req.length bytes of the buffer at DMA address
> + * req->req.dma for the IN direction.
> + *
> + * When more data is provided than the maximum payload size, the hardware splits
> + * this up into several payloads automatically. Moreover, ep->bytes_per_buffer
> + * is always set to a multiple of the maximum payload (restricted to the valid
> + * number of maximum payloads during high bandwidth isochronous or interrupt
> + * transfers)
> + *
> + * All descriptors are enabled from the beginning and we only generate an
> + * interrupt for the last one indicating that the entire request has been pushed
> + * to hardware.
> + */
> +static int gr_setup_in_desc_list(struct gr_ep *ep, struct gr_request *req,
> + gfp_t gfp_flags)
> +{
> + u16 bytes_left; /* Bytes left in req to provide descriptors for */
> + u16 bytes_used; /* Bytes in req accommodated for */
> + int ret = 0;
> +
> + req->first_desc = NULL; /* Signals that no allocation is done yet */
> + bytes_left = req->req.length;
> + bytes_used = 0;
> + do { /* Allow for zero length packets */
> + dma_addr_t start = req->req.dma + bytes_used;
> + u16 size = min(bytes_left, ep->bytes_per_buffer);
> +
> + ret = gr_add_dma_desc(ep, req, start, size, gfp_flags);
> + if (ret)
> + goto alloc_err;
> +
> + bytes_left -= size;
> + bytes_used += size;
> + } while (bytes_left > 0);
> +
> + /*
> + * Send an extra zero length packet to indicate that no more data is
> + * available when req->req.zero is set and the data length is even
> + * multiples of ep->ep.maxpacket.
> + */
> + if (req->req.zero && (req->req.length % ep->ep.maxpacket == 0)) {
> + ret = gr_add_dma_desc(ep, req, 0, 0, gfp_flags);
> + if (ret)
> + goto alloc_err;
> + }
> +
> + /*
> + * For IN packets we only want to know when the last packet has been
> + * transmitted (not just put into internal buffers).
> + */
> + req->last_desc->ctrl |= GR_DESC_IN_CTRL_PI;
> +
> + return 0;
> +
> +alloc_err:
> + gr_free_dma_desc_chain(ep->dev, req);
> +
> + return ret;
> +}
> +
> +/* Must be called with dev->lock held */
> +static int gr_queue(struct gr_ep *ep, struct gr_request *req, gfp_t gfp_flags)
> +{
> + struct gr_udc *dev = ep->dev;
> + int ret;
> +
> + if (unlikely(!ep->ep.desc && ep->num != 0)) {
> + dev_err(dev->dev, "No ep descriptor for %s\n", ep->ep.name);
> + return -EINVAL;
> + }
> +
> + if (unlikely(!req->req.buf || !list_empty(&req->queue))) {
> + dev_err(dev->dev,
> + "Invalid request for %s: buf=%p list_empty=%d\n",
> + ep->ep.name, req->req.buf, list_empty(&req->queue));
> + return -EINVAL;
> + }
> +
> + /*
> + * The DMA controller can not handle smaller OUT buffers than
> + * maxpacket. It could lead to buffer overruns if unexpectedly long
> + * packet are received.
> + */
> + if (!ep->is_in && (req->req.length % ep->ep.maxpacket) != 0) {
> + dev_err(dev->dev,
> + "OUT request length %d is not multiple of maxpacket\n",
> + req->req.length);
> + return -EMSGSIZE;
> + }
> +
> + if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
> + dev_err(dev->dev, "-ESHUTDOWN");
> + return -ESHUTDOWN;
> + }
> +
> + /* Can't touch registers when suspended */
> + if (dev->ep0state == GR_EP0_SUSPEND) {
> + dev_err(dev->dev, "-EBUSY");
> + return -EBUSY;
> + }
> +
> + /* Set up DMA mapping in case the caller didn't */
> + ret = usb_gadget_map_request(&dev->gadget, &req->req, ep->is_in);
> + if (ret) {
> + dev_err(dev->dev, "usb_gadget_map_request");
> + return ret;
> + }
> +
> + if (ep->is_in)
> + ret = gr_setup_in_desc_list(ep, req, gfp_flags);
> + else
> + ret = gr_setup_out_desc_list(ep, req, gfp_flags);
> + if (ret)
> + return ret;
> +
> + req->req.status = -EINPROGRESS;
> + req->req.actual = 0;
> + list_add_tail(&req->queue, &ep->queue);
> +
> + /* Start DMA if not started, otherwise interrupt handler handles it */
> + if (!ep->dma_start && likely(!ep->stopped))
> + gr_start_dma(ep);
> +
> + return 0;
> +}
> +
> +/*
> + * Queue a request from within the driver.
> + *
> + * Must be called with dev->lock held.
> + */
> +static inline int gr_queue_int(struct gr_ep *ep, struct gr_request *req,
> + gfp_t gfp_flags)
> +{
> + if (ep->is_in)
> + gr_dbgprint_request("RESP", ep, req);
> +
> + return gr_queue(ep, req, gfp_flags);
> +}
> +
> +/* ---------------------------------------------------------------------- */
> +/* General helper functions */
> +
> +/*
> + * Dequeue ALL requests.
> + *
> + * Must be called with dev->lock held and irqs disabled.
> + */
> +static void gr_ep_nuke(struct gr_ep *ep)
> +{
> + struct gr_request *req;
> + struct gr_udc *dev;
> +
> + dev = ep->dev;
> +
> + ep->stopped = 1;
> + ep->dma_start = 0;
> + gr_abort_dma(ep);
> +
> + while (!list_empty(&ep->queue)) {
> + req = list_first_entry(&ep->queue, struct gr_request, queue);
> + gr_finish_request(ep, req, -ESHUTDOWN);
> + }
> +}
> +
> +/*
> + * Reset the hardware state of this endpoint.
> + *
> + * Must be called with dev->lock held.
> + */
> +static void gr_ep_reset(struct gr_ep *ep)
> +{
> + gr_write32(&ep->regs->epctrl, 0);
> + gr_write32(&ep->regs->dmactrl, 0);
> +
> + ep->ep.maxpacket = MAX_CTRL_PL_SIZE;
> + ep->ep.desc = NULL;
> + ep->stopped = 1;
> + ep->dma_start = 0;
> +}
> +
> +/*
> + * Generate STALL on ep0in/out.
> + *
> + * Must be called with dev->lock held.
> + */
> +static void gr_control_stall(struct gr_udc *dev)
> +{
> + u32 epctrl;
> +
> + epctrl = gr_read32(&dev->epo[0].regs->epctrl);
> + gr_write32(&dev->epo[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
> + epctrl = gr_read32(&dev->epi[0].regs->epctrl);
> + gr_write32(&dev->epi[0].regs->epctrl, epctrl | GR_EPCTRL_CS);
> +
> + dev->ep0state = GR_EP0_STALL;
> +}
> +
> +/*
> + * Halts, halts and wedges, or clears halt for an endpoint.
> + *
> + * Must be called with dev->lock held.
> + */
> +static int gr_ep_halt_wedge(struct gr_ep *ep, int halt, int wedge, int fromhost)
> +{
> + u32 epctrl;
> + int retval = 0;
> +
> + if (ep->num && !ep->ep.desc)
> + return -EINVAL;
> +
> + if (ep->num && ep->ep.desc->bmAttributes == USB_ENDPOINT_XFER_ISOC)
> + return -EOPNOTSUPP;
> +
> + /* Never actually halt ep0, and therefore never clear halt for ep0 */
> + if (!ep->num) {
> + if (halt && !fromhost) {
> + /* ep0 halt from gadget - generate protocol stall */
> + gr_control_stall(ep->dev);
> + dev_dbg(ep->dev->dev, "EP: stall ep0\n");
> + return 0;
> + }
> + return -EINVAL;
> + }
> +
> + dev_dbg(ep->dev->dev, "EP: %s halt %s\n",
> + (halt ? (wedge ? "wedge" : "set") : "clear"), ep->ep.name);
> +
> + epctrl = gr_read32(&ep->regs->epctrl);
> + if (halt) {
> + /* Set HALT */
> + gr_write32(&ep->regs->epctrl, epctrl | GR_EPCTRL_EH);
> + ep->stopped = 1;
> + if (wedge)
> + ep->wedged = 1;
> + } else {
> + gr_write32(&ep->regs->epctrl, epctrl & ~GR_EPCTRL_EH);
> + ep->stopped = 0;
> + ep->wedged = 0;
> +
> + /* Things might have been queued up in the meantime */
> + if (!ep->dma_start)
> + gr_start_dma(ep);
> + }
> +
> + return retval;
> +}
> +
> +/* Must be called with dev->lock held */
> +static inline void gr_set_ep0state(struct gr_udc *dev, enum gr_ep0state value)
> +{
> + if (dev->ep0state != value)
> + dev_vdbg(dev->dev, "STATE: ep0state=%s\n",
> + gr_ep0state_string(value));
> + dev->ep0state = value;
> +}
> +
> +/*
> + * Should only be called when endpoints can not generate interrupts.
> + *
> + * Must be called with dev->lock held.
> + */
> +static void gr_disable_interrupts_and_pullup(struct gr_udc *dev)
> +{
> + gr_write32(&dev->regs->control, 0);
> + wmb(); /* Make sure that we do not deny one of our interrupts */
> + dev->irq_enabled = 0;
> +}
> +
> +/*
> + * Stop all device activity and disable data line pullup.
> + *
> + * Must be called with dev->lock held and irqs disabled.
> + */
> +static void gr_stop_activity(struct gr_udc *dev)
> +{
> + struct gr_ep *ep;
> +
> + list_for_each_entry(ep, &dev->ep_list, ep_list)
> + gr_ep_nuke(ep);
> +
> + gr_disable_interrupts_and_pullup(dev);
> +
> + gr_set_ep0state(dev, GR_EP0_DISCONNECT);
> + usb_gadget_set_state(&dev->gadget, USB_STATE_NOTATTACHED);
> +}
> +
> +/* ---------------------------------------------------------------------- */
> +/* ep0 setup packet handling */
> +
> +static void gr_ep0_testmode_complete(struct usb_ep *_ep,
> + struct usb_request *_req)
> +{
> + struct gr_ep *ep;
> + struct gr_udc *dev;
> + u32 control;
> +
> + ep = container_of(_ep, struct gr_ep, ep);
> + dev = ep->dev;
> +
> + spin_lock(&dev->lock);
> +
> + control = gr_read32(&dev->regs->control);
> + control |= GR_CONTROL_TM | (dev->test_mode << GR_CONTROL_TS_POS);
> + gr_write32(&dev->regs->control, control);
> +
> + spin_unlock(&dev->lock);
> +}
> +
> +static void gr_ep0_dummy_complete(struct usb_ep *_ep, struct usb_request *_req)
> +{
> + /* Nothing needs to be done here */
> +}
> +
> +/*
> + * Queue a response on ep0in.
> + *
> + * Must be called with dev->lock held.
> + */
> +static int gr_ep0_respond(struct gr_udc *dev, u8 *buf, int length,
> + void (*complete)(struct usb_ep *ep,
> + struct usb_request *req))
> +{
> + u8 *reqbuf = dev->ep0reqi->req.buf;
> + int status;
> + int i;
> +
> + for (i = 0; i < length; i++)
> + reqbuf[i] = buf[i];
> + dev->ep0reqi->req.length = length;
> + dev->ep0reqi->req.complete = complete;
> +
> + status = gr_queue_int(&dev->epi[0], dev->ep0reqi, GFP_ATOMIC);
> + if (status < 0)
> + dev_err(dev->dev,
> + "Could not queue ep0in setup response: %d\n", status);
> +
> + return status;
> +}
> +
> +/*
> + * Queue a 2 byte response on ep0in.
> + *
> + * Must be called with dev->lock held.
> + */
> +static inline int gr_ep0_respond_u16(struct gr_udc *dev, u16 response)
> +{
> + __le16 le_response = cpu_to_le16(response);
> +
> + return gr_ep0_respond(dev, (u8 *)&le_response, 2,
> + gr_ep0_dummy_complete);
> +}
> +
> +/*
> + * Queue a ZLP response on ep0in.
> + *
> + * Must be called with dev->lock held.
> + */
> +static inline int gr_ep0_respond_empty(struct gr_udc *dev)
> +{
> + return gr_ep0_respond(dev, NULL, 0, gr_ep0_dummy_complete);
> +}
> +
> +/*
> + * This is run when a SET_ADDRESS request is received. First writes
> + * the new address to the control register which is updated internally
> + * when the next IN packet is ACKED.
> + *
> + * Must be called with dev->lock held.
> + */
> +static void gr_set_address(struct gr_udc *dev, u8 address)
> +{
> + u32 control;
> +
> + control = gr_read32(&dev->regs->control) & ~GR_CONTROL_UA_MASK;
> + control |= (address << GR_CONTROL_UA_POS) & GR_CONTROL_UA_MASK;
> + control |= GR_CONTROL_SU;
> + gr_write32(&dev->regs->control, control);
> +}
> +
> +/*
> + * Returns negative for STALL, 0 for successful handling and positive for
> + * delegation.
> + *
> + * Must be called with dev->lock held.
> + */
> +static int gr_device_request(struct gr_udc *dev, u8 type, u8 request,
> + u16 value, u16 index)
> +{
> + u16 response;
> + u8 test;
> +
> + switch (request) {
> + case USB_REQ_SET_ADDRESS:
> + dev_dbg(dev->dev, "STATUS: address %d\n", value & 0xff);
> + gr_set_address(dev, value & 0xff);
> + if (value)
> + usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
> + else
> + usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
> + return gr_ep0_respond_empty(dev);
> +
> + case USB_REQ_GET_STATUS:
> + /* Self powered | remote wakeup */
> + response = 0x0001 | (dev->remote_wakeup ? 0x0002 : 0);
> + return gr_ep0_respond_u16(dev, response);
> +
> + case USB_REQ_SET_FEATURE:
> + switch (value) {
> + case USB_DEVICE_REMOTE_WAKEUP:
> + /* Allow remote wakeup */
> + dev->remote_wakeup = 1;
> + return gr_ep0_respond_empty(dev);
> +
> + case USB_DEVICE_TEST_MODE:
> + /* The hardware does not support TEST_FORCE_EN */
> + test = index >> 8;
> + if (test >= TEST_J && test <= TEST_PACKET) {
> + dev->test_mode = test;
> + return gr_ep0_respond(dev, NULL, 0,
> + gr_ep0_testmode_complete);
> + }
> + }
> + break;
> +
> + case USB_REQ_CLEAR_FEATURE:
> + switch (value) {
> + case USB_DEVICE_REMOTE_WAKEUP:
> + /* Disallow remote wakeup */
> + dev->remote_wakeup = 0;
> + return gr_ep0_respond_empty(dev);
> + }
> + break;
> + }
> +
> + return 1; /* Delegate the rest */
> +}
> +
> +/*
> + * Returns negative for STALL, 0 for successful handling and positive for
> + * delegation.
> + *
> + * Must be called with dev->lock held.
> + */
> +static int gr_interface_request(struct gr_udc *dev, u8 type, u8 request,
> + u16 value, u16 index)
> +{
> + if (dev->gadget.state != USB_STATE_CONFIGURED)
> + return -1;
> +
> + /*
> + * Should return STALL for invalid interfaces, but udc driver does not
> + * know anything about that. However, many gadget drivers do not handle
> + * GET_STATUS so we need to take care of that.
> + */
> +
> + switch (request) {
> + case USB_REQ_GET_STATUS:
> + return gr_ep0_respond_u16(dev, 0x0000);
> +
> + case USB_REQ_SET_FEATURE:
> + case USB_REQ_CLEAR_FEATURE:
> + /*
> + * No possible valid standard requests. Still let gadget drivers
> + * have a go at it.
> + */
> + break;
> + }
> +
> + return 1; /* Delegate the rest */
> +}
> +
> +/*
> + * Returns negative for STALL, 0 for successful handling and positive for
> + * delegation.
> + *
> + * Must be called with dev->lock held.
> + */
> +static int gr_endpoint_request(struct gr_udc *dev, u8 type, u8 request,
> + u16 value, u16 index)
> +{
> + struct gr_ep *ep;
> + int status;
> + int halted;
> + u8 epnum = index & USB_ENDPOINT_NUMBER_MASK;
> + u8 is_in = index & USB_ENDPOINT_DIR_MASK;
> +
> + if ((is_in && epnum >= dev->nepi) || (!is_in && epnum >= dev->nepo))
> + return -1;
> +
> + if (dev->gadget.state != USB_STATE_CONFIGURED && epnum != 0)
> + return -1;
> +
> + ep = (is_in ? &dev->epi[epnum] : &dev->epo[epnum]);
> +
> + switch (request) {
> + case USB_REQ_GET_STATUS:
> + halted = gr_read32(&ep->regs->epctrl) & GR_EPCTRL_EH;
> + return gr_ep0_respond_u16(dev, halted ? 0x0001 : 0);
> +
> + case USB_REQ_SET_FEATURE:
> + switch (value) {
> + case USB_ENDPOINT_HALT:
> + status = gr_ep_halt_wedge(ep, 1, 0, 1);
> + if (status >= 0)
> + status = gr_ep0_respond_empty(dev);
> + return status;
> + }
> + break;
> +
> + case USB_REQ_CLEAR_FEATURE:
> + switch (value) {
> + case USB_ENDPOINT_HALT:
> + if (ep->wedged)
> + return -1;
> + status = gr_ep_halt_wedge(ep, 0, 0, 1);
> + if (status >= 0)
> + status = gr_ep0_respond_empty(dev);
> + return status;
> + }
> + break;
> + }
> +
> + return 1; /* Delegate the rest */
> +}
> +
> +/* Must be called with dev->lock held */
> +static void gr_ep0out_requeue(struct gr_udc *dev)
> +{
> + int ret = gr_queue_int(&dev->epo[0], dev->ep0reqo, GFP_ATOMIC);
> +
> + if (ret)
> + dev_err(dev->dev, "Could not queue ep0out setup request: %d\n",
> + ret);
> +}
> +
> +/*
> + * The main function dealing with setup requests on ep0.
> + *
> +/* Must be called with dev->lock held and irqs disabled
> + */
> +static void gr_ep0_setup(struct gr_udc *dev, struct gr_request *req)
> +{
> + union {
> + struct usb_ctrlrequest ctrl;
> + u8 raw[8];
> + u32 word[2];
> + } u;
> + u8 type;
> + u8 request;
> + u16 value;
> + u16 index;
> + u16 length;
> + int i;
> + int status;
> +
> + /* Restore from ep0 halt */
> + if (dev->ep0state == GR_EP0_STALL) {
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + if (!req->req.actual)
> + goto out;
> + }
> +
> + if (dev->ep0state == GR_EP0_ISTATUS) {
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + if (req->req.actual > 0)
> + dev_dbg(dev->dev,
> + "Unexpected setup packet at state %s\n",
> + gr_ep0state_string(GR_EP0_ISTATUS));
> + else
> + goto out; /* Got expected ZLP */
> + } else if (dev->ep0state != GR_EP0_SETUP) {
> + dev_info(dev->dev,
> + "Unexpected ep0out request at state %s - stalling\n",
> + gr_ep0state_string(dev->ep0state));
> + gr_control_stall(dev);
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + goto out;
> + } else if (!req->req.actual) {
> + dev_dbg(dev->dev, "Unexpected ZLP at state %s\n",
> + gr_ep0state_string(dev->ep0state));
> + goto out;
> + }
> +
> + /* Handle SETUP packet */
> + for (i = 0; i < req->req.actual; i++)
> + u.raw[i] = ((u8 *)req->req.buf)[i];
> +
> + type = u.ctrl.bRequestType;
> + request = u.ctrl.bRequest;
> + value = le16_to_cpu(u.ctrl.wValue);
> + index = le16_to_cpu(u.ctrl.wIndex);
> + length = le16_to_cpu(u.ctrl.wLength);
> +
> + gr_dbgprint_devreq(dev, type, request, value, index, length);
> +
> + /* Check for data stage */
> + if (length) {
> + if (type & USB_DIR_IN)
> + gr_set_ep0state(dev, GR_EP0_IDATA);
> + else
> + gr_set_ep0state(dev, GR_EP0_ODATA);
> + }
> +
> + status = 1; /* Positive status flags delegation */
> + if ((type & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
> + switch (type & USB_RECIP_MASK) {
> + case USB_RECIP_DEVICE:
> + status = gr_device_request(dev, type, request,
> + value, index);
> + break;
> + case USB_RECIP_ENDPOINT:
> + status = gr_endpoint_request(dev, type, request,
> + value, index);
> + break;
> + case USB_RECIP_INTERFACE:
> + status = gr_interface_request(dev, type, request,
> + value, index);
> + break;
> + }
> + }
> +
> + if (status > 0) {
> + spin_unlock(&dev->lock);
> +
> + dev_vdbg(dev->dev, "DELEGATE\n");
> + status = dev->driver->setup(&dev->gadget, &u.ctrl);
> +
> + spin_lock(&dev->lock);
> + }
> +
> + /* Generate STALL on both ep0out and ep0in if requested */
> + if (unlikely(status < 0)) {
> + dev_vdbg(dev->dev, "STALL\n");
> + gr_control_stall(dev);
> + }
> +
> + if ((type & USB_TYPE_MASK) == USB_TYPE_STANDARD &&
> + request == USB_REQ_SET_CONFIGURATION) {
> + if (!value) {
> + dev_dbg(dev->dev, "STATUS: deconfigured\n");
> + usb_gadget_set_state(&dev->gadget, USB_STATE_ADDRESS);
> + } else if (status >= 0) {
> + /* Not configured unless gadget OK:s it */
> + dev_dbg(dev->dev, "STATUS: configured: %d\n", value);
> + usb_gadget_set_state(&dev->gadget,
> + USB_STATE_CONFIGURED);
> + }
> + }
> +
> + /* Get ready for next stage */
> + if (dev->ep0state == GR_EP0_ODATA)
> + gr_set_ep0state(dev, GR_EP0_OSTATUS);
> + else if (dev->ep0state == GR_EP0_IDATA)
> + gr_set_ep0state(dev, GR_EP0_ISTATUS);
> + else
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> +
> +out:
> + gr_ep0out_requeue(dev);
> +}
> +
> +/* ---------------------------------------------------------------------- */
> +/* VBUS and USB reset handling */
> +
> +/* Must be called with dev->lock held and irqs disabled */
> +static void gr_vbus_connected(struct gr_udc *dev, u32 status)
> +{
> + u32 control;
> +
> + dev->gadget.speed = GR_SPEED(status);
> + usb_gadget_set_state(&dev->gadget, USB_STATE_POWERED);
> +
> + /* Turn on full interrupts and pullup */
> + control = (GR_CONTROL_SI | GR_CONTROL_UI | GR_CONTROL_VI |
> + GR_CONTROL_SP | GR_CONTROL_EP);
> + gr_write32(&dev->regs->control, control);
> +}
> +
> +/* Must be called with dev->lock held */
> +static void gr_enable_vbus_detect(struct gr_udc *dev)
> +{
> + u32 status;
> +
> + dev->irq_enabled = 1;
> + wmb(); /* Make sure we do not ignore an interrupt */
> + gr_write32(&dev->regs->control, GR_CONTROL_VI);
> +
> + /* Take care of the case we are already plugged in at this point */
> + status = gr_read32(&dev->regs->status);
> + if (status & GR_STATUS_VB)
> + gr_vbus_connected(dev, status);
> +}
> +
> +/* Must be called with dev->lock held and irqs disabled */
> +static void gr_vbus_disconnected(struct gr_udc *dev)
> +{
> + gr_stop_activity(dev);
> +
> + /* Report disconnect */
> + if (dev->driver && dev->driver->disconnect) {
> + spin_unlock(&dev->lock);
> +
> + dev->driver->disconnect(&dev->gadget);
> +
> + spin_lock(&dev->lock);
> + }
> +
> + gr_enable_vbus_detect(dev);
> +}
> +
> +/* Must be called with dev->lock held and irqs disabled */
> +static void gr_udc_usbreset(struct gr_udc *dev, u32 status)
> +{
> + gr_set_address(dev, 0);
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + usb_gadget_set_state(&dev->gadget, USB_STATE_DEFAULT);
> + dev->gadget.speed = GR_SPEED(status);
> +
> + gr_ep_nuke(&dev->epo[0]);
> + gr_ep_nuke(&dev->epi[0]);
> + dev->epo[0].stopped = 0;
> + dev->epi[0].stopped = 0;
> + gr_ep0out_requeue(dev);
> +}
> +
> +/* ---------------------------------------------------------------------- */
> +/* Irq handling */
> +
> +/*
> + * Handles interrupts from in endpoints. Returns whether something was handled.
> + *
> + * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
> + */
> +static int gr_handle_in_ep(struct gr_ep *ep)
> +{
> + struct gr_request *req;
> +
> + req = list_first_entry(&ep->queue, struct gr_request, queue);
> + if (!req->last_desc)
> + return 0;
> +
> + if (gr_read32(&req->last_desc->ctrl) & GR_DESC_IN_CTRL_EN)
> + return 0; /* Not put in hardware buffers yet */
> +
> + if (gr_read32(&ep->regs->epstat) & (GR_EPSTAT_B1 | GR_EPSTAT_B0))
> + return 0; /* Not transmitted yet, still in hardware buffers */
> +
> + /* Write complete */
> + gr_dma_advance(ep, 0);
> +
> + return 1;
> +}
> +
> +/*
> + * Handles interrupts from out endpoints. Returns whether something was handled.
> + *
> + * Must be called with dev->lock held, irqs disabled and with !ep->stopped.
> + */
> +static int gr_handle_out_ep(struct gr_ep *ep)
> +{
> + u32 ep_dmactrl;
> + u32 ctrl;
> + u16 len;
> + struct gr_request *req;
> + struct gr_udc *dev = ep->dev;
> +
> + req = list_first_entry(&ep->queue, struct gr_request, queue);
> + if (!req->curr_desc)
> + return 0;
> +
> + ctrl = gr_read32(&req->curr_desc->ctrl);
> + if (ctrl & GR_DESC_OUT_CTRL_EN)
> + return 0; /* Not received yet */
> +
> + /* Read complete */
> + len = ctrl & GR_DESC_OUT_CTRL_LEN_MASK;
> + req->req.actual += len;
> + if (ctrl & GR_DESC_OUT_CTRL_SE)
> + req->setup = 1;
> +
> + if (len < ep->ep.maxpacket || req->req.actual == req->req.length) {
> + /* Short packet or the expected size - we are done */
> +
> + if ((ep == &dev->epo[0]) && (dev->ep0state == GR_EP0_OSTATUS)) {
> + /*
> + * Send a status stage ZLP to ack the DATA stage in the
> + * OUT direction. This needs to be done before
> + * gr_dma_advance as that can lead to a call to
> + * ep0_setup that can change dev->ep0state.
> + */
> + gr_ep0_respond_empty(dev);
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + }
> +
> + gr_dma_advance(ep, 0);
> + } else {
> + /* Not done yet. Enable the next descriptor to receive more. */
> + req->curr_desc = req->curr_desc->next_desc;
> + req->curr_desc->ctrl |= GR_DESC_OUT_CTRL_EN;
> +
> + ep_dmactrl = gr_read32(&ep->regs->dmactrl);
> + gr_write32(&ep->regs->dmactrl, ep_dmactrl | GR_DMACTRL_DA);
> + }
> +
> + return 1;
> +}
> +
> +/*
> + * Handle state changes. Returns whether something was handled.
> + *
> + * Must be called with dev->lock held and irqs disabled.
> + */
> +static int gr_handle_state_changes(struct gr_udc *dev)
> +{
> + u32 status = gr_read32(&dev->regs->status);
> + int handled = 0;
> + int powstate = !(dev->gadget.state == USB_STATE_NOTATTACHED ||
> + dev->gadget.state == USB_STATE_ATTACHED);
> +
> + /* VBUS valid detected */
> + if (!powstate && (status & GR_STATUS_VB)) {
> + dev_dbg(dev->dev, "STATUS: vbus valid detected\n");
> + gr_vbus_connected(dev, status);
> + handled = 1;
> + }
> +
> + /* Disconnect */
> + if (powstate && !(status & GR_STATUS_VB)) {
> + dev_dbg(dev->dev, "STATUS: vbus invalid detected\n");
> + gr_vbus_disconnected(dev);
> + handled = 1;
> + }
> +
> + /* USB reset detected */
> + if (status & GR_STATUS_UR) {
> + dev_dbg(dev->dev, "STATUS: USB reset - speed is %s\n",
> + GR_SPEED_STR(status));
> + gr_write32(&dev->regs->status, GR_STATUS_UR);
> + gr_udc_usbreset(dev, status);
> + handled = 1;
> + }
> +
> + /* Speed change */
> + if (dev->gadget.speed != GR_SPEED(status)) {
> + dev_dbg(dev->dev, "STATUS: USB Speed change to %s\n",
> + GR_SPEED_STR(status));
> + dev->gadget.speed = GR_SPEED(status);
> + handled = 1;
> + }
> +
> + /* Going into suspend */
> + if ((dev->ep0state != GR_EP0_SUSPEND) && !(status & GR_STATUS_SU)) {
> + dev_dbg(dev->dev, "STATUS: USB suspend\n");
> + gr_set_ep0state(dev, GR_EP0_SUSPEND);
> + dev->suspended_from = dev->gadget.state;
> + usb_gadget_set_state(&dev->gadget, USB_STATE_SUSPENDED);
> +
> + if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
> + dev->driver && dev->driver->suspend) {
> + spin_unlock(&dev->lock);
> +
> + dev->driver->suspend(&dev->gadget);
> +
> + spin_lock(&dev->lock);
> + }
> + handled = 1;
> + }
> +
> + /* Coming out of suspend */
> + if ((dev->ep0state == GR_EP0_SUSPEND) && (status & GR_STATUS_SU)) {
> + dev_dbg(dev->dev, "STATUS: USB resume\n");
> + if (dev->suspended_from == USB_STATE_POWERED)
> + gr_set_ep0state(dev, GR_EP0_DISCONNECT);
> + else
> + gr_set_ep0state(dev, GR_EP0_SETUP);
> + usb_gadget_set_state(&dev->gadget, dev->suspended_from);
> +
> + if ((dev->gadget.speed != USB_SPEED_UNKNOWN) &&
> + dev->driver && dev->driver->resume) {
> + spin_unlock(&dev->lock);
> +
> + dev->driver->resume(&dev->gadget);
> +
> + spin_lock(&dev->lock);
> + }
> + handled = 1;
> + }
> +
> + return handled;
> +}
> +
> +/* Non-interrupt context irq handler */
> +static irqreturn_t gr_irq_handler(int irq, void *_dev)
> +{
> + struct gr_udc *dev = _dev;
> + struct gr_ep *ep;
> + int handled = 0;
> + int i;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&dev->lock, flags);
> +
> + if (!dev->irq_enabled)
> + goto out;
> +
> + /*
> + * Check IN ep interrupts. We check these before the OUT eps because
> + * some gadgets reuse the request that might already be currently
> + * outstanding and needs to be completed (mainly setup requests).
> + */
> + for (i = 0; i < dev->nepi; i++) {
> + ep = &dev->epi[i];
> + if (!ep->stopped && !ep->callback && !list_empty(&ep->queue))
> + handled = gr_handle_in_ep(ep) || handled;
> + }
> +
> + /* Check OUT ep interrupts */
> + for (i = 0; i < dev->nepo; i++) {
> + ep = &dev->epo[i];
> + if (!ep->stopped && !ep->callback && !list_empty(&ep->queue))
> + handled = gr_handle_out_ep(ep) || handled;
> + }
> +
> + /* Check status interrupts */
> + handled = gr_handle_state_changes(dev) || handled;
> +
> + /*
> + * Check AMBA DMA errors. Only check if we didn't find anything else to
> + * handle because this shouldn't happen if we did everything right.
> + */
> + if (!handled) {
> + list_for_each_entry(ep, &dev->ep_list, ep_list) {
> + if (gr_read32(&ep->regs->dmactrl) & GR_DMACTRL_AE) {
> + dev_err(dev->dev,
> + "AMBA Error occurred for %s\n",
> + ep->ep.name);
> + handled = 1;
> + }
> + }
> + }
> +
> +out:
> + spin_unlock_irqrestore(&dev->lock, flags);
> +
> + return handled ? IRQ_HANDLED : IRQ_NONE;
> +}
> +
> +/* Interrupt context irq handler */
> +static irqreturn_t gr_irq(int irq, void *_dev)
> +{
> + struct gr_udc *dev = _dev;
> +
> + if (!dev->irq_enabled)
> + return IRQ_NONE;
> +
> + return IRQ_WAKE_THREAD;
> +}
> +
> +/* ---------------------------------------------------------------------- */
> +/* USB ep ops */
> +
> +/* Enable endpoint. Not for ep0in and ep0out that are handled separately. */
> +static int gr_ep_enable(struct usb_ep *_ep,
> + const struct usb_endpoint_descriptor *desc)
> +{
> + struct gr_udc *dev;
> + struct gr_ep *ep;
> + u8 mode;
> + u8 nt;
> + u16 max;
> + u16 buffer_size = 0;
> + u32 epctrl;
> +
> + ep = container_of(_ep, struct gr_ep, ep);
> + if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT)
> + return -EINVAL;
> +
> + dev = ep->dev;
> +
> + /* 'ep0' IN and OUT are reserved */
> + if (ep == &dev->epo[0] || ep == &dev->epi[0])
> + return -EINVAL;
> +
> + if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
> + return -ESHUTDOWN;
> +
> + /* Make sure we are clear for enabling */
> + epctrl = gr_read32(&ep->regs->epctrl);
> + if (epctrl & GR_EPCTRL_EV)
> + return -EBUSY;
> +
> + /* Check that directions match */
> + if (!ep->is_in != !usb_endpoint_dir_in(desc))
> + return -EINVAL;
> +
> + /* Check ep num */
> + if ((!ep->is_in && ep->num >= dev->nepo) ||
> + (ep->is_in && ep->num >= dev->nepi))
> + return -EINVAL;
> +
> + if (usb_endpoint_xfer_control(desc)) {
> + mode = 0;
> + } else if (usb_endpoint_xfer_isoc(desc)) {
> + mode = 1;
> + } else if (usb_endpoint_xfer_bulk(desc)) {
> + mode = 2;
> + } else if (usb_endpoint_xfer_int(desc)) {
> + mode = 3;
> + } else {
> + dev_err(dev->dev, "Unknown transfer type for %s\n",
> + ep->ep.name);
> + return -EINVAL;
> + }
> +
> + /*
> + * Bits 10-0 set the max payload. 12-11 set the number of
> + * additional transactions.
> + */
> + max = 0x7ff & usb_endpoint_maxp(desc);
> + nt = 0x3 & (usb_endpoint_maxp(desc) >> 11);
> + buffer_size = GR_BUFFER_SIZE(epctrl);
> + if (nt && (mode == 0 || mode == 2)) {
> + dev_err(dev->dev,
> + "%s mode: multiple trans./microframe not valid\n",
> + (mode == 2 ? "Bulk" : "Control"));
> + return -EINVAL;
> + } else if (nt == 0x11) {
> + dev_err(dev->dev, "Invalid value for trans./microframe\n");
> + return -EINVAL;
> + } else if ((nt + 1) * max > buffer_size) {
> + dev_err(dev->dev, "Hw buffer size %d < max payload %d * %d\n",
> + buffer_size, (nt + 1), max);
> + return -EINVAL;
> + } else if (max == 0) {
> + dev_err(dev->dev, "Max payload cannot be set to 0\n");
> + return -EINVAL;
> + }
> +
> + spin_lock(&ep->dev->lock);
> +
> + if (!ep->stopped) {
> + spin_unlock(&ep->dev->lock);
> + return -EBUSY;
> + }
> +
> + ep->stopped = 0;
> + ep->wedged = 0;
> + ep->ep.desc = desc;
> + ep->ep.maxpacket = max;
> + ep->dma_start = 0;
> +
> +
> + if (nt) {
> + /*
> + * Maximum possible size of all payloads in one microframe
> + * regardless of direction when using high-bandwidth mode.
> + */
> + ep->bytes_per_buffer = (nt + 1) * max;
> + } else if (ep->is_in) {
> + /*
> + * The biggest multiple of maximum packet size that fits into
> + * the buffer. The hardware will split up into many packets in
> + * the IN direction.
> + */
> + ep->bytes_per_buffer = (buffer_size / max) * max;
> + } else {
> + /*
> + * Only single packets will be placed the buffers in the OUT
> + * direction.
> + */
> + ep->bytes_per_buffer = max;
> + }
> +
> + epctrl = (max << GR_EPCTRL_MAXPL_POS)
> + | (nt << GR_EPCTRL_NT_POS)
> + | (mode << GR_EPCTRL_TT_POS)
> + | GR_EPCTRL_EV;
> + if (ep->is_in)
> + epctrl |= GR_EPCTRL_PI;
> + gr_write32(&ep->regs->epctrl, epctrl);
> +
> + gr_write32(&ep->regs->dmactrl, GR_DMACTRL_IE | GR_DMACTRL_AI);
> +
> + spin_unlock(&ep->dev->lock);
> +
> + dev_dbg(ep->dev->dev, "EP: %s enabled - %s with %d bytes/buffer\n",
> + ep->ep.name, gr_modestring[mode], ep->bytes_per_buffer);
> + return 0;
> +}
> +
> +/* Disable endpoint. Not for ep0in and ep0out that are handled separately. */
> +static int gr_ep_disable(struct usb_ep *_ep)
> +{
> + struct gr_ep *ep;
> + struct gr_udc *dev;
> + unsigned long flags;
> +
> + ep = container_of(_ep, struct gr_ep, ep);
> + if (!_ep || !ep->ep.desc)
> + return -ENODEV;
> +
> + dev = ep->dev;
> +
> + /* 'ep0' IN and OUT are reserved */
> + if (ep == &dev->epo[0] || ep == &dev->epi[0])
> + return -EINVAL;
> +
> + if (dev->ep0state == GR_EP0_SUSPEND)
> + return -EBUSY;
> +
> + dev_dbg(ep->dev->dev, "EP: disable %s\n", ep->ep.name);
> +
> + spin_lock_irqsave(&dev->lock, flags);
> +
> + gr_ep_nuke(ep);
> + gr_ep_reset(ep);
> + ep->ep.desc = NULL;
> +
> + spin_unlock_irqrestore(&dev->lock, flags);
> +
> + return 0;
> +}
> +
> +/*
> + * Frees a request, but not any DMA buffers associated with it
> + * (gr_finish_request should already have taken care of that).
> + */
> +static void gr_free_request(struct usb_ep *_ep, struct usb_request *_req)
> +{
> + struct gr_request *req;
> +
> + if (!_ep || !_req)
> + return;
> + req = container_of(_req, struct gr_request, req);
> +
> + /* Leads to memory leak */
> + WARN(!list_empty(&req->queue),
> + "request not dequeued properly before freeing\n");
> +
> + kfree(req);
> +}
> +
> +/* Queue a request from the gadget */
> +static int gr_queue_ext(struct usb_ep *_ep, struct usb_request *_req,
> + gfp_t gfp_flags)
> +{
> + struct gr_ep *ep;
> + struct gr_request *req;
> + struct gr_udc *dev;
> + int ret;
> +
> + if (unlikely(!_ep || !_req))
> + return -EINVAL;
> +
> + ep = container_of(_ep, struct gr_ep, ep);
> + req = container_of(_req, struct gr_request, req);
> + dev = ep->dev;
> +
> + spin_lock(&ep->dev->lock);
> +
> + /*
> + * The ep0 pointer in the gadget struct is used both for ep0in and
> + * ep0out. In a data stage in the out direction ep0out needs to be used
> + * instead of the default ep0in. Completion functions might use
> + * driver_data, so that needs to be copied as well.
> + */
> + if ((ep == &dev->epi[0]) && (dev->ep0state == GR_EP0_ODATA)) {
> + ep = &dev->epo[0];
> + ep->ep.driver_data = dev->epi[0].ep.driver_data;
> + }
> +
> + if (ep->is_in)
> + gr_dbgprint_request("EXTERN", ep, req);
> +
> + ret = gr_queue(ep, req, gfp_flags);
> +
> + spin_unlock(&ep->dev->lock);
> +
> + return ret;
> +}
> +
> +/* Dequeue JUST ONE request */
> +static int gr_dequeue(struct usb_ep *_ep, struct usb_request *_req)
> +{
> + struct gr_request *req;
> + struct gr_ep *ep;
> + struct gr_udc *dev;
> + int ret = 0;
> + unsigned long flags;
> +
> + ep = container_of(_ep, struct gr_ep, ep);
> + if (!_ep || !_req || (!ep->ep.desc && ep->num != 0))
> + return -EINVAL;
> + dev = ep->dev;
> + if (!dev->driver)
> + return -ESHUTDOWN;
> +
> + /* We can't touch (DMA) registers when suspended */
> + if (dev->ep0state == GR_EP0_SUSPEND)
> + return -EBUSY;
> +
> + spin_lock_irqsave(&dev->lock, flags);
> +
> + /* Make sure it's actually queued on this endpoint */
> + list_for_each_entry(req, &ep->queue, queue) {
> + if (&req->req == _req)
> + break;
> + }
> + if (&req->req != _req) {
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + if (list_first_entry(&ep->queue, struct gr_request, queue) == req) {
> + /* This request is currently being processed */
> + gr_abort_dma(ep);
> + if (ep->stopped)
> + gr_finish_request(ep, req, -ECONNRESET);
> + else
> + gr_dma_advance(ep, -ECONNRESET);
> + } else if (!list_empty(&req->queue)) {
> + /* Not being processed - gr_finish_request dequeues it */
> + gr_finish_request(ep, req, -ECONNRESET);
> + } else {
> + ret = -EOPNOTSUPP;
> + }
> +
> +out:
> + spin_unlock_irqrestore(&dev->lock, flags);
> +
> + return ret;
> +}
> +
> +/* Helper for gr_set_halt and gr_set_wedge */
> +static int gr_set_halt_wedge(struct usb_ep *_ep, int halt, int wedge)
> +{
> + int ret;
> + struct gr_ep *ep;
> +
> + if (!_ep)
> + return -ENODEV;
> + ep = container_of(_ep, struct gr_ep, ep);
> +
> + spin_lock(&ep->dev->lock);
> +
> + /* Halting an IN endpoint should fail if queue is not empty */
> + if (halt && ep->is_in && !list_empty(&ep->queue)) {
> + ret = -EAGAIN;
> + goto out;
> + }
> +
> + ret = gr_ep_halt_wedge(ep, halt, wedge, 0);
> +
> +out:
> + spin_unlock(&ep->dev->lock);
> +
> + return ret;
> +}
> +
> +/* Halt endpoint */
> +static int gr_set_halt(struct usb_ep *_ep, int halt)
> +{
> + return gr_set_halt_wedge(_ep, halt, 0);
> +}
> +
> +/* Halt and wedge endpoint */
> +static int gr_set_wedge(struct usb_ep *_ep)
> +{
> + return gr_set_halt_wedge(_ep, 1, 1);
> +}
> +
> +/*
> + * Return the total number of bytes currently stored in the internal buffers of
> + * the endpoint.
> + */
> +static int gr_fifo_status(struct usb_ep *_ep)
> +{
> + struct gr_ep *ep;
> + u32 epstat;
> + u32 bytes = 0;
> +
> + if (!_ep)
> + return -ENODEV;
> + ep = container_of(_ep, struct gr_ep, ep);
> +
> + epstat = gr_read32(&ep->regs->epstat);
> +
> + if (epstat & GR_EPSTAT_B0)
> + bytes += (epstat & GR_EPSTAT_B0CNT_MASK) >> GR_EPSTAT_B0CNT_POS;
> + if (epstat & GR_EPSTAT_B1)
> + bytes += (epstat & GR_EPSTAT_B1CNT_MASK) >> GR_EPSTAT_B1CNT_POS;
> +
> + return bytes;
> +}
> +
> +
> +/* Empty data from internal buffers of an endpoint. */
> +static void gr_fifo_flush(struct usb_ep *_ep)
> +{
> + struct gr_ep *ep;
> + u32 epctrl;
> +
> + if (!_ep)
> + return;
> + ep = container_of(_ep, struct gr_ep, ep);
> + dev_vdbg(ep->dev->dev, "EP: flush fifo %s\n", ep->ep.name);
> +
> + spin_lock(&ep->dev->lock);
> +
> + epctrl = gr_read32(&ep->regs->epctrl);
> + epctrl |= GR_EPCTRL_CB;
> + gr_write32(&ep->regs->epctrl, epctrl);
> +
> + spin_unlock(&ep->dev->lock);
> +}
> +
> +static struct usb_ep_ops gr_ep_ops = {
> + .enable = gr_ep_enable,
> + .disable = gr_ep_disable,
> +
> + .alloc_request = gr_alloc_request,
> + .free_request = gr_free_request,
> +
> + .queue = gr_queue_ext,
> + .dequeue = gr_dequeue,
> +
> + .set_halt = gr_set_halt,
> + .set_wedge = gr_set_wedge,
> + .fifo_status = gr_fifo_status,
> + .fifo_flush = gr_fifo_flush,
> +};
> +
> +/* ---------------------------------------------------------------------- */
> +/* USB Gadget ops */
> +
> +static int gr_get_frame(struct usb_gadget *_gadget)
> +{
> + struct gr_udc *dev;
> +
> + if (!_gadget)
> + return -ENODEV;
> + dev = container_of(_gadget, struct gr_udc, gadget);
> + return gr_read32(&dev->regs->status) & GR_STATUS_FN_MASK;
> +}
> +
> +static int gr_wakeup(struct usb_gadget *_gadget)
> +{
> + struct gr_udc *dev;
> +
> + if (!_gadget)
> + return -ENODEV;
> + dev = container_of(_gadget, struct gr_udc, gadget);
> +
> + /* Remote wakeup feature not enabled by host*/
> + if (!dev->remote_wakeup)
> + return -EINVAL;
> +
> + spin_lock(&dev->lock);
> +
> + gr_write32(&dev->regs->control,
> + gr_read32(&dev->regs->control) | GR_CONTROL_RW);
> +
> + spin_unlock(&dev->lock);
> +
> + return 0;
> +}
> +
> +static int gr_pullup(struct usb_gadget *_gadget, int is_on)
> +{
> + struct gr_udc *dev;
> + u32 control;
> +
> + if (!_gadget)
> + return -ENODEV;
> + dev = container_of(_gadget, struct gr_udc, gadget);
> +
> + spin_lock(&dev->lock);
> +
> + control = gr_read32(&dev->regs->control);
> + if (is_on)
> + control |= GR_CONTROL_EP;
> + else
> + control &= ~GR_CONTROL_EP;
> + gr_write32(&dev->regs->control, control);
> +
> + spin_unlock(&dev->lock);
> +
> + return 0;
> +}
> +
> +static int gr_udc_start(struct usb_gadget *gadget,
> + struct usb_gadget_driver *driver)
> +{
> + struct gr_udc *dev = to_gr_udc(gadget);
> +
> + spin_lock(&dev->lock);
> +
> + /* Hook up the driver */
> + driver->driver.bus = NULL;
> + dev->driver = driver;
> +
> + /* Get ready for host detection */
> + gr_enable_vbus_detect(dev);
> +
> + spin_unlock(&dev->lock);
> +
> + dev_info(dev->dev, "Started with gadget driver '%s'\n",
> + driver->driver.name);
> +
> + return 0;
> +}
> +
> +static int gr_udc_stop(struct usb_gadget *gadget,
> + struct usb_gadget_driver *driver)
> +{
> + struct gr_udc *dev = to_gr_udc(gadget);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&dev->lock, flags);
> +
> + dev->driver = NULL;
> + gr_stop_activity(dev);
> +
> + spin_unlock_irqrestore(&dev->lock, flags);
> +
> + dev_info(dev->dev, "Stopped\n");
> +
> + return 0;
> +}
> +
> +static const struct usb_gadget_ops gr_ops = {
> + .get_frame = gr_get_frame,
> + .wakeup = gr_wakeup,
> + .pullup = gr_pullup,
> + .udc_start = gr_udc_start,
> + .udc_stop = gr_udc_stop,
> + /* Other operations not supported */
> +};
> +
> +/* ---------------------------------------------------------------------- */
> +/* Module probe, removal and of-matching */
> +
> +static const char * const onames[] = {
> + "ep0out", "ep1out", "ep2out", "ep3out", "ep4out", "ep5out",
> + "ep6out", "ep7out", "ep8out", "ep9out", "ep10out", "ep11out",
> + "ep12out", "ep13out", "ep14out", "ep15out"
> +};
> +
> +static const char * const inames[] = {
> + "ep0in", "ep1in", "ep2in", "ep3in", "ep4in", "ep5in",
> + "ep6in", "ep7in", "ep8in", "ep9in", "ep10in", "ep11in",
> + "ep12in", "ep13in", "ep14in", "ep15in"
> +};
> +
> +/* Must be called with dev->lock held */
> +static int gr_ep_init(struct gr_udc *dev, int num, int is_in)
> +{
> + struct gr_ep *ep;
> + struct gr_request *req;
> + struct usb_request *_req;
> + void *buf;
> +
> + if (is_in) {
> + ep = &dev->epi[num];
> + ep->ep.name = inames[num];
> + ep->regs = &dev->regs->epi[num];
> + } else {
> + ep = &dev->epo[num];
> + ep->ep.name = onames[num];
> + ep->regs = &dev->regs->epo[num];
> + }
> +
> + gr_ep_reset(ep);
> + ep->num = num;
> + ep->is_in = is_in;
> + ep->dev = dev;
> + ep->ep.ops = &gr_ep_ops;
> + INIT_LIST_HEAD(&ep->queue);
> +
> + if (num == 0) {
> + _req = gr_alloc_request(&ep->ep, GFP_KERNEL);
> + buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_KERNEL);
> + if (!_req || !buf) {
> + /* possible _req freed by gr_probe via gr_remove */
> + return -ENOMEM;
> + }
> +
> + req = container_of(_req, struct gr_request, req);
> + req->req.buf = buf;
> + req->req.length = MAX_CTRL_PL_SIZE;
> +
> + if (is_in)
> + dev->ep0reqi = req; /* Complete gets set as used */
> + else
> + dev->ep0reqo = req; /* Completion treated separately */
> +

This line:
> + ep->ep.maxpacket = MAX_CTRL_PL_SIZE;
should be replaced with:
+ usb_ep_set_maxpacket_limit(&ep->ep, MAX_CTRL_PL_SIZE);

> + ep->bytes_per_buffer = MAX_CTRL_PL_SIZE;
> + } else {

And you should also initialize other endpoints with maximum packet size
value supported by your hardware:
+ usb_ep_set_maxpacket_limit(&ep->ep, ~0);

Value ~0 will work well, and it indicates that hardware supports maximum
maxpacket value from USB standard.

> + list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
> + }
> + list_add_tail(&ep->ep_list, &dev->ep_list);
> +
> + return 0;
> +}
> +
> +/* Must be called with dev->lock held */
> +static int gr_udc_init(struct gr_udc *dev)
> +{
> + u32 epctrl_val;
> + u32 dmactrl_val;
> + int i;
> + int ret = 0;
> +
> + gr_set_address(dev, 0);
> +
> + INIT_LIST_HEAD(&dev->gadget.ep_list);
> + dev->gadget.speed = USB_SPEED_UNKNOWN;
> + dev->gadget.ep0 = &dev->epi[0].ep;
> +
> + INIT_LIST_HEAD(&dev->ep_list);
> + gr_set_ep0state(dev, GR_EP0_DISCONNECT);
> +
> + for (i = 0; i < dev->nepo; i++) {
> + ret = gr_ep_init(dev, i, 0);
> + if (ret)
> + return ret;
> + }
> +
> + for (i = 0; i < dev->nepi; i++) {
> + ret = gr_ep_init(dev, i, 1);
> + if (ret)
> + return ret;
> + }
> +
> + /* Must be disabled by default */
> + dev->remote_wakeup = 0;
> +
> + /* Enable ep0out and ep0in */
> + epctrl_val = (MAX_CTRL_PL_SIZE << GR_EPCTRL_MAXPL_POS) | GR_EPCTRL_EV;
> + dmactrl_val = GR_DMACTRL_IE | GR_DMACTRL_AI;
> + gr_write32(&dev->epo[0].regs->epctrl, epctrl_val);
> + gr_write32(&dev->epi[0].regs->epctrl, epctrl_val | GR_EPCTRL_PI);
> + gr_write32(&dev->epo[0].regs->dmactrl, dmactrl_val);
> + gr_write32(&dev->epi[0].regs->dmactrl, dmactrl_val);
> +
> + return 0;
> +}
> +
> +static int gr_remove(struct platform_device *ofdev)
> +{
> + struct gr_udc *dev = dev_get_drvdata(&ofdev->dev);
> +
> + if (dev->added)
> + usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
> + if (dev->driver)
> + return -EBUSY;
> +
> + gr_dfs_delete(dev);
> + if (dev->desc_pool)
> + dma_pool_destroy(dev->desc_pool);
> + dev_set_drvdata(&ofdev->dev, NULL);
> +
> + gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
> + gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
> +
> + return 0;
> +}
> +static int gr_request_irq(struct gr_udc *dev, int irq)
> +{
> + return devm_request_threaded_irq(dev->dev, irq, gr_irq, gr_irq_handler,
> + IRQF_SHARED, driver_name, dev);
> +}
> +
> +static int gr_probe(struct platform_device *ofdev)
> +{
> + struct gr_udc *dev;
> + struct resource *res;
> + struct gr_regs __iomem *regs;
> + int retval;
> + u32 status;
> +
> + dev = devm_kzalloc(&ofdev->dev, sizeof(*dev), GFP_KERNEL);
> + if (!dev)
> + return -ENOMEM;
> + dev->dev = &ofdev->dev;
> +
> + res = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
> + regs = devm_ioremap_resource(dev->dev, res);
> + if (IS_ERR(regs))
> + return PTR_ERR(regs);
> +
> + dev->irq = irq_of_parse_and_map(dev->dev->of_node, 0);
> + if (!dev->irq) {
> + dev_err(dev->dev, "No irq found\n");
> + return -ENODEV;
> + }
> +
> + /* Some core configurations has separate irqs for IN and OUT events */
> + dev->irqi = irq_of_parse_and_map(dev->dev->of_node, 1);
> + if (dev->irqi) {
> + dev->irqo = irq_of_parse_and_map(dev->dev->of_node, 2);
> + if (!dev->irqo) {
> + dev_err(dev->dev, "Found irqi but not irqo\n");
> + return -ENODEV;
> + }
> + }
> +
> + dev->gadget.name = driver_name;
> + dev->gadget.max_speed = USB_SPEED_HIGH;
> + dev->gadget.ops = &gr_ops;
> +
> + spin_lock_init(&dev->lock);
> + dev->regs = regs;
> +
> + dev_set_drvdata(&ofdev->dev, dev);
> +
> + /* Determine number of endpoints and data interface mode */
> + status = gr_read32(&dev->regs->status);
> + dev->nepi = ((status & GR_STATUS_NEPI_MASK) >> GR_STATUS_NEPI_POS) + 1;
> + dev->nepo = ((status & GR_STATUS_NEPO_MASK) >> GR_STATUS_NEPO_POS) + 1;
> +
> + if (!(status & GR_STATUS_DM)) {
> + dev_err(dev->dev, "Slave mode cores are not supported\n");
> + return -ENODEV;
> + }
> +
> + /* --- Effects of the following calls might need explicit cleanup --- */
> +
> + /* Create DMA pool for descriptors */
> + dev->desc_pool = dma_pool_create("desc_pool", dev->dev,
> + sizeof(struct gr_dma_desc), 4, 0);
> + if (!dev->desc_pool) {
> + dev_err(dev->dev, "Could not allocate DMA pool");
> + return -ENOMEM;
> + }
> +
> + spin_lock(&dev->lock);
> +
> + /* Inside lock so that no gadget can use this udc until probe is done */
> + retval = usb_add_gadget_udc(dev->dev, &dev->gadget);
> + if (retval) {
> + dev_err(dev->dev, "Could not add gadget udc");
> + goto out;
> + }
> + dev->added = 1;
> +
> + retval = gr_udc_init(dev);
> + if (retval)
> + goto out;
> +
> + gr_dfs_create(dev);
> +
> + /* Clear all interrupt enables that might be left on since last boot */
> + gr_disable_interrupts_and_pullup(dev);
> +
> + retval = gr_request_irq(dev, dev->irq);
> + if (retval) {
> + dev_err(dev->dev, "Failed to request irq %d\n", dev->irq);
> + goto out;
> + }
> +
> + if (dev->irqi) {
> + retval = gr_request_irq(dev, dev->irqi);
> + if (retval) {
> + dev_err(dev->dev, "Failed to request irqi %d\n",
> + dev->irqi);
> + goto out;
> + }
> + retval = gr_request_irq(dev, dev->irqo);
> + if (retval) {
> + dev_err(dev->dev, "Failed to request irqo %d\n",
> + dev->irqo);
> + goto out;
> + }
> + }
> +
> + if (dev->irqi)
> + dev_info(dev->dev, "regs: %p, irqs %d, %d, %d\n", dev->regs,
> + dev->irq, dev->irqi, dev->irqo);
> + else
> + dev_info(dev->dev, "regs: %p, irq %d\n", dev->regs, dev->irq);
> +
> +out:
> + spin_unlock(&dev->lock);
> +
> + if (retval)
> + gr_remove(ofdev);
> +
> + return retval;
> +}
> +
> +static struct of_device_id gr_match[] = {
> + {.name = "GAISLER_USBDC"},
> + {.name = "01_021"},
> + {},
> +};
> +MODULE_DEVICE_TABLE(of, gr_match);
> +
> +static struct platform_driver gr_driver = {
> + .driver = {
> + .name = DRIVER_NAME,
> + .owner = THIS_MODULE,
> + .of_match_table = gr_match,
> + },
> + .probe = gr_probe,
> + .remove = gr_remove,
> +};
> +module_platform_driver(gr_driver);
> +
> +MODULE_AUTHOR("Aeroflex Gaisler AB.");
> +MODULE_DESCRIPTION(DRIVER_DESC);
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/usb/gadget/gr_udc.h b/drivers/usb/gadget/gr_udc.h
> new file mode 100644
> index 0000000..8388897
> --- /dev/null
> +++ b/drivers/usb/gadget/gr_udc.h
> @@ -0,0 +1,220 @@
> +/*
> + * USB Peripheral Controller driver for Aeroflex Gaisler GRUSBDC.
> + *
> + * 2013 (c) Aeroflex Gaisler AB
> + *
> + * This driver supports GRUSBDC USB Device Controller cores available in the
> + * GRLIB VHDL IP core library.
> + *
> + * Full documentation of the GRUSBDC core can be found here:
> + * http://www.gaisler.com/products/grlib/grip.pdf
> + *
> + * 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.
> + *
> + * Contributors:
> + * - Andreas Larsson <andreas@xxxxxxxxxxx>
> + * - Marko Isomaki
> + */
> +
> +/* Control registers on the AMBA bus */
> +
> +#define GR_MAXEP 16 /* Max # endpoints for *each* direction */
> +
> +struct gr_epregs {
> + u32 epctrl;
> + union {
> + struct { /* Slave mode*/
> + u32 slvctrl;
> + u32 slvdata;
> + };
> + struct { /* DMA mode*/
> + u32 dmactrl;
> + u32 dmaaddr;
> + };
> + };
> + u32 epstat;
> +};
> +
> +struct gr_regs {
> + struct gr_epregs epo[GR_MAXEP]; /* 0x000 - 0x0fc */
> + struct gr_epregs epi[GR_MAXEP]; /* 0x100 - 0x1fc */
> + u32 control; /* 0x200 */
> + u32 status; /* 0x204 */
> +};
> +
> +#define GR_EPCTRL_BUFSZ_SCALER 8
> +#define GR_EPCTRL_BUFSZ_MASK 0xffe00000
> +#define GR_EPCTRL_BUFSZ_POS 21
> +#define GR_EPCTRL_PI BIT(20)
> +#define GR_EPCTRL_CB BIT(19)
> +#define GR_EPCTRL_CS BIT(18)
> +#define GR_EPCTRL_MAXPL_MASK 0x0003ff80
> +#define GR_EPCTRL_MAXPL_POS 7
> +#define GR_EPCTRL_NT_MASK 0x00000060
> +#define GR_EPCTRL_NT_POS 5
> +#define GR_EPCTRL_TT_MASK 0x00000018
> +#define GR_EPCTRL_TT_POS 3
> +#define GR_EPCTRL_EH BIT(2)
> +#define GR_EPCTRL_ED BIT(1)
> +#define GR_EPCTRL_EV BIT(0)
> +
> +#define GR_DMACTRL_AE BIT(10)
> +#define GR_DMACTRL_AD BIT(3)
> +#define GR_DMACTRL_AI BIT(2)
> +#define GR_DMACTRL_IE BIT(1)
> +#define GR_DMACTRL_DA BIT(0)
> +
> +#define GR_EPSTAT_PT BIT(29)
> +#define GR_EPSTAT_PR BIT(29)
> +#define GR_EPSTAT_B1CNT_MASK 0x1fff0000
> +#define GR_EPSTAT_B1CNT_POS 16
> +#define GR_EPSTAT_B0CNT_MASK 0x0000fff8
> +#define GR_EPSTAT_B0CNT_POS 3
> +#define GR_EPSTAT_B1 BIT(2)
> +#define GR_EPSTAT_B0 BIT(1)
> +#define GR_EPSTAT_BS BIT(0)
> +
> +#define GR_CONTROL_SI BIT(31)
> +#define GR_CONTROL_UI BIT(30)
> +#define GR_CONTROL_VI BIT(29)
> +#define GR_CONTROL_SP BIT(28)
> +#define GR_CONTROL_FI BIT(27)
> +#define GR_CONTROL_EP BIT(14)
> +#define GR_CONTROL_DH BIT(13)
> +#define GR_CONTROL_RW BIT(12)
> +#define GR_CONTROL_TS_MASK 0x00000e00
> +#define GR_CONTROL_TS_POS 9
> +#define GR_CONTROL_TM BIT(8)
> +#define GR_CONTROL_UA_MASK 0x000000fe
> +#define GR_CONTROL_UA_POS 1
> +#define GR_CONTROL_SU BIT(0)
> +
> +#define GR_STATUS_NEPI_MASK 0xf0000000
> +#define GR_STATUS_NEPI_POS 28
> +#define GR_STATUS_NEPO_MASK 0x0f000000
> +#define GR_STATUS_NEPO_POS 24
> +#define GR_STATUS_DM BIT(23)
> +#define GR_STATUS_SU BIT(17)
> +#define GR_STATUS_UR BIT(16)
> +#define GR_STATUS_VB BIT(15)
> +#define GR_STATUS_SP BIT(14)
> +#define GR_STATUS_AF_MASK 0x00003800
> +#define GR_STATUS_AF_POS 11
> +#define GR_STATUS_FN_MASK 0x000007ff
> +#define GR_STATUS_FN_POS 0
> +
> +
> +#define MAX_CTRL_PL_SIZE 64 /* As per USB standard for full and high speed */
> +
> +/*-------------------------------------------------------------------------*/
> +
> +/* Driver data structures and utilities */
> +
> +struct gr_dma_desc {
> + u32 ctrl;
> + u32 data;
> + u32 next;
> +
> + /* These must be last because hw uses the previous three */
> + u32 paddr;
> + struct gr_dma_desc *next_desc;
> +};
> +
> +#define GR_DESC_OUT_CTRL_SE BIT(17)
> +#define GR_DESC_OUT_CTRL_IE BIT(15)
> +#define GR_DESC_OUT_CTRL_NX BIT(14)
> +#define GR_DESC_OUT_CTRL_EN BIT(13)
> +#define GR_DESC_OUT_CTRL_LEN_MASK 0x00001fff
> +
> +#define GR_DESC_IN_CTRL_MO BIT(18)
> +#define GR_DESC_IN_CTRL_PI BIT(17)
> +#define GR_DESC_IN_CTRL_ML BIT(16)
> +#define GR_DESC_IN_CTRL_IE BIT(15)
> +#define GR_DESC_IN_CTRL_NX BIT(14)
> +#define GR_DESC_IN_CTRL_EN BIT(13)
> +#define GR_DESC_IN_CTRL_LEN_MASK 0x00001fff
> +
> +#define GR_DESC_DMAADDR_MASK 0xfffffffc
> +
> +struct gr_ep {
> + struct usb_ep ep;
> + struct gr_udc *dev;
> + u16 bytes_per_buffer;
> + unsigned int dma_start;
> + struct gr_epregs __iomem *regs;
> +
> + unsigned num:8;
> + unsigned is_in:1;
> + unsigned stopped:1;
> + unsigned wedged:1;
> + unsigned callback:1;
> +
> + /* analogous to a host-side qh */
> + struct list_head queue;
> +
> + struct list_head ep_list;
> +};
> +
> +struct gr_request {
> + struct usb_request req;
> + struct list_head queue;
> +
> + /* Chain of dma descriptors */
> + struct gr_dma_desc *first_desc; /* First in the chain */
> + struct gr_dma_desc *curr_desc; /* Current descriptor */
> + struct gr_dma_desc *last_desc; /* Last in the chain */
> +
> + u8 setup; /* Setup packet */
> +};
> +
> +enum gr_ep0state {
> + GR_EP0_DISCONNECT = 0, /* No host */
> + GR_EP0_SETUP, /* Between STATUS ack and SETUP report */
> + GR_EP0_IDATA, /* IN data stage */
> + GR_EP0_ODATA, /* OUT data stage */
> + GR_EP0_ISTATUS, /* Status stage after IN data stage */
> + GR_EP0_OSTATUS, /* Status stage after OUT data stage */
> + GR_EP0_STALL, /* Data or status stages */
> + GR_EP0_SUSPEND, /* USB suspend */
> +};
> +
> +struct gr_udc {
> + struct usb_gadget gadget;
> + struct gr_ep epi[GR_MAXEP];
> + struct gr_ep epo[GR_MAXEP];
> + struct usb_gadget_driver *driver;
> + struct dma_pool *desc_pool;
> + struct device *dev;
> +
> + enum gr_ep0state ep0state;
> + struct gr_request *ep0reqo;
> + struct gr_request *ep0reqi;
> +
> + struct gr_regs __iomem *regs;
> + int irq;
> + int irqi;
> + int irqo;
> +
> + unsigned added:1;
> + unsigned irq_enabled:1;
> + unsigned remote_wakeup:1;
> +
> + u8 test_mode;
> +
> + enum usb_device_state suspended_from;
> +
> + unsigned int nepi;
> + unsigned int nepo;
> +
> + struct list_head ep_list;
> +
> + spinlock_t lock; /* General lock, a.k.a. "dev->lock" in comments */
> +
> + struct dentry *dfs_root;
> + struct dentry *dfs_state;
> +};
> +
> +#define to_gr_udc(gadget) (container_of((gadget), struct gr_udc, gadget))
>

--
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/

Next message: Levente Kurusa: "Re: [PATCH 21/38] workqueue: add missing put_device call"
Previous message: Sebastian Andrzej Siewior: "[PATCH 5/5] mfd: input: iio: ti_amm335x: Rework TSC/ADC synchronization"
In reply to: Andreas Larsson: "[PATCH v4] usb: gadget: Add UDC driver for Aeroflex Gaisler GRUSBDC"
Next in thread: Andreas Larsson: "Re: [PATCH v4] usb: gadget: Add UDC driver for Aeroflex Gaisler GRUSBDC"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]