omap_udc.rar_otg

/* * omap_udc.c -- for OMAP full speed udc; most chips support OTG. * * Copyright (C) 2004 Texas Instruments, Inc. * Copyright (C) 2004-2005 David Brownell * * OMAP2 & DMA support by Kyungmin Park <[email protected]> * * 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. */ #undef DEBUG #undef VERBOSE #include <linux/module.h> #include <linux/kernel.h> #include <linux/ioport.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/delay.h> #include <linux/slab.h> #include <linux/timer.h> #include <linux/list.h> #include <linux/interrupt.h> #include <linux/proc_fs.h> #include <linux/mm.h> #include <linux/moduleparam.h> #include <linux/platform_device.h> #include <linux/usb/ch9.h> #include <linux/usb/gadget.h> #include <linux/usb/otg.h> #include <linux/dma-mapping.h> #include <linux/clk.h> #include <linux/err.h> #include <linux/prefetch.h> #include <linux/io.h> #include <asm/byteorder.h> #include <asm/irq.h> #include <asm/unaligned.h> #include <asm/mach-types.h> #include <linux/omap-dma.h> #include <mach/usb.h> #include "omap_udc.h" #undef USB_TRACE /* bulk DMA seems to be behaving for both IN and OUT */ #define USE_DMA /* ISO too */ #define USE_ISO #define DRIVER_DESC "OMAP UDC driver" #define DRIVER_VERSION "4 October 2004" #define OMAP_DMA_USB_W2FC_TX0 29 #define OMAP_DMA_USB_W2FC_RX0 26 /* * The OMAP UDC needs _very_ early endpoint setup: before enabling the * D+ pullup to allow enumeration. That's too early for the gadget * framework to use from usb_endpoint_enable(), which happens after * enumeration as part of activating an interface. (But if we add an * optional new "UDC not yet running" state to the gadget driver model, * even just during driver binding, the endpoint autoconfig logic is the * natural spot to manufacture new endpoints.) * * So instead of using endpoint enable calls to control the hardware setup, * this driver defines a "fifo mode" parameter. It's used during driver * initialization to choose among a set of pre-defined endpoint configs. * See omap_udc_setup() for available modes, or to add others. That code * lives in an init section, so use this driver as a module if you need * to change the fifo mode after the kernel boots. * * Gadget drivers normally ignore endpoints they don't care about, and * won't include them in configuration descriptors. That means only * misbehaving hosts would even notice they exist. */ #ifdef USE_ISO static unsigned fifo_mode = 3; #else static unsigned fifo_mode; #endif /* "modprobe omap_udc fifo_mode=42", or else as a kernel * boot parameter "omap_udc:fifo_mode=42" */ module_param(fifo_mode, uint, 0); MODULE_PARM_DESC(fifo_mode, "endpoint configuration"); #ifdef USE_DMA static bool use_dma = 1; /* "modprobe omap_udc use_dma=y", or else as a kernel * boot parameter "omap_udc:use_dma=y" */ module_param(use_dma, bool, 0); MODULE_PARM_DESC(use_dma, "enable/disable DMA"); #else /* !USE_DMA */ /* save a bit of code */ #define use_dma 0 #endif /* !USE_DMA */ static const char driver_name[] = "omap_udc"; static const char driver_desc[] = DRIVER_DESC; /*-------------------------------------------------------------------------*/ /* there's a notion of "current endpoint" for modifying endpoint * state, and PIO access to its FIFO. */ static void use_ep(struct omap_ep *ep, u16 select) { u16 num = ep->bEndpointAddress & 0x0f; if (ep->bEndpointAddress & USB_DIR_IN) num |= UDC_EP_DIR; omap_writew(num | select, UDC_EP_NUM); /* when select, MUST deselect later !! */ } static inline void deselect_ep(void) { u16 w; w = omap_readw(UDC_EP_NUM); w &= ~UDC_EP_SEL; omap_writew(w, UDC_EP_NUM); /* 6 wait states before TX will happen */ } static void dma_channel_claim(struct omap_ep *ep, unsigned preferred); /*-------------------------------------------------------------------------*/ static int omap_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) { struct omap_ep *ep = container_of(_ep, struct omap_ep, ep); struct omap_udc *udc; unsigned long flags; u16 maxp; /* catch various bogus parameters */ if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT || ep->bEndpointAddress != desc->bEndpointAddress || ep->maxpacket < usb_endpoint_maxp(desc)) { DBG("%s, bad ep or descriptor\n", __func__); return -EINVAL; } maxp = usb_endpoint_maxp(desc); if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK && maxp != ep->maxpacket) || usb_endpoint_maxp(desc) > ep->maxpacket || !desc->wMaxPacketSize) { DBG("%s, bad %s maxpacket\n", __func__, _ep->name); return -ERANGE; } #ifdef USE_ISO if ((desc->bmAttributes == USB_ENDPOINT_XFER_ISOC && desc->bInterval != 1)) { /* hardware wants period = 1; USB allows 2^(Interval-1) */ DBG("%s, unsupported ISO period %dms\n", _ep->name, 1 << (desc->bInterval - 1)); return -EDOM; } #else if (desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) { DBG("%s, ISO nyet\n", _ep->name); return -EDOM; } #endif /* xfer types must match, except that interrupt ~= bulk */ if (ep->bmAttributes != desc->bmAttributes && ep->bmAttributes != USB_ENDPOINT_XFER_BULK && desc->bmAttributes != USB_ENDPOINT_XFER_INT) { DBG("%s, %s type mismatch\n", __func__, _ep->name); return -EINVAL; } udc = ep->udc; if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) { DBG("%s, bogus device state\n", __func__); return -ESHUTDOWN; } spin_lock_irqsave(&udc->lock, flags); ep->ep.desc = desc; ep->irqs = 0; ep->stopped = 0; ep->ep.maxpacket = maxp; /* set endpoint to initial state */ ep->dma_channel = 0; ep->has_dma = 0; ep->lch = -1; use_ep(ep, UDC_EP_SEL); omap_writew(udc->clr_halt, UDC_CTRL); ep->ackwait = 0; deselect_ep(); if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) list_add(&ep->iso, &udc->iso); /* maybe assign a DMA channel to this endpoint */ if (use_dma && desc->bmAttributes == USB_ENDPOINT_XFER_BULK) /* FIXME ISO can dma, but prefers first channel */ dma_channel_claim(ep, 0); /* PIO OUT may RX packets */ if (desc->bmAttributes != USB_ENDPOINT_XFER_ISOC && !ep->has_dma && !(ep->bEndpointAddress & USB_DIR_IN)) { omap_writew(UDC_SET_FIFO_EN, UDC_CTRL); ep->ackwait = 1 + ep->double_buf; } spin_unlock_irqrestore(&udc->lock, flags); VDBG("%s enabled\n", _ep->name); return 0; } static void nuke(struct omap_ep *, int status); static int omap_ep_disable(struct usb_ep *_ep) { struct omap_ep *ep = container_of(_ep, struct omap_ep, ep); unsigned long flags; if (!_ep || !ep->ep.desc) { DBG("%s, %s not enabled\n", __func__, _ep ? ep->ep.name : NULL); return -EINVAL; } spin_lock_irqsave(&ep->udc->lock, flags); ep->ep.desc = NULL; nuke(ep, -ESHUTDOWN); ep->ep.maxpacket = ep->maxpacket; ep->has_dma = 0; omap_writew(UDC_SET_HALT, UDC_CTRL); list_del_init(&ep->iso); del_timer(&ep->timer); spin_unlock_irqrestore(&ep->udc->lock, flags); VDBG("%s disabled\n", _ep->name); return 0; } /*-------------------------------------------------------------------------*/ static struct usb_request * omap_alloc_request(struct usb_ep *ep, gfp_t gfp_flags) { struct omap_req *req; req = kzalloc(sizeof(*req), gfp_flags); if (!req) return NULL; INIT_LIST_HEAD(&req->queue); return &req->req; } static void omap_free_request(struct usb_ep *ep, struct usb_request *_req) { struct omap_req *req = container_of(_req, struct omap_req, req); kfree(req); } /*-------------------------------------------------------------------------*/ static void done(struct omap_ep *ep, struct omap_req *req, int status) { struct omap_udc *udc = ep->udc; unsigned stopped = ep->stopped; list_del_init(&req->queue); if (req->req.status == -EINPROGRESS) req->req.status = status; else status = req->req.s