mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
1579 lines
38 KiB
C
1579 lines
38 KiB
C
/*
|
|
* driver/usb/gadget/imx_udc.c
|
|
*
|
|
* Copyright (C) 2005 Mike Lee <eemike@gmail.com>
|
|
* Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
|
|
*
|
|
* 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.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/list.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/io.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/device.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/usb/ch9.h>
|
|
#include <linux/usb/gadget.h>
|
|
|
|
#include <mach/usb.h>
|
|
#include <mach/hardware.h>
|
|
|
|
#include "imx_udc.h"
|
|
|
|
static const char driver_name[] = "imx_udc";
|
|
static const char ep0name[] = "ep0";
|
|
|
|
void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
|
|
enum ep0_state stat);
|
|
|
|
/*******************************************************************************
|
|
* IMX UDC hardware related functions
|
|
*******************************************************************************
|
|
*/
|
|
|
|
void imx_udc_enable(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
__raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA,
|
|
imx_usb->base + USB_CTRL);
|
|
imx_usb->gadget.speed = USB_SPEED_FULL;
|
|
}
|
|
|
|
void imx_udc_disable(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
|
|
__raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA),
|
|
imx_usb->base + USB_CTRL);
|
|
|
|
ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
|
|
imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
|
|
}
|
|
|
|
void imx_udc_reset(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int temp = __raw_readl(imx_usb->base + USB_ENAB);
|
|
|
|
/* set RST bit */
|
|
__raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB);
|
|
|
|
/* wait RST bit to clear */
|
|
do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST);
|
|
|
|
/* wait CFG bit to assert */
|
|
do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
|
|
|
|
/* udc module is now ready */
|
|
}
|
|
|
|
void imx_udc_config(struct imx_udc_struct *imx_usb)
|
|
{
|
|
u8 ep_conf[5];
|
|
u8 i, j, cfg;
|
|
struct imx_ep_struct *imx_ep;
|
|
|
|
/* wait CFG bit to assert */
|
|
do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
|
|
|
|
/* Download the endpoint buffer for endpoint 0. */
|
|
for (j = 0; j < 5; j++) {
|
|
i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00);
|
|
__raw_writeb(i, imx_usb->base + USB_DDAT);
|
|
do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY);
|
|
}
|
|
|
|
/* Download the endpoint buffers for endpoints 1-5.
|
|
* We specify two configurations, one interface
|
|
*/
|
|
for (cfg = 1; cfg < 3; cfg++) {
|
|
for (i = 1; i < IMX_USB_NB_EP; i++) {
|
|
imx_ep = &imx_usb->imx_ep[i];
|
|
/* EP no | Config no */
|
|
ep_conf[0] = (i << 4) | (cfg << 2);
|
|
/* Type | Direction */
|
|
ep_conf[1] = (imx_ep->bmAttributes << 3) |
|
|
(EP_DIR(imx_ep) << 2);
|
|
/* Max packet size */
|
|
ep_conf[2] = imx_ep->fifosize;
|
|
/* TRXTYP */
|
|
ep_conf[3] = 0xC0;
|
|
/* FIFO no */
|
|
ep_conf[4] = i;
|
|
|
|
D_INI(imx_usb->dev,
|
|
"<%s> ep%d_conf[%d]:"
|
|
"[%02x-%02x-%02x-%02x-%02x]\n",
|
|
__func__, i, cfg,
|
|
ep_conf[0], ep_conf[1], ep_conf[2],
|
|
ep_conf[3], ep_conf[4]);
|
|
|
|
for (j = 0; j < 5; j++) {
|
|
__raw_writeb(ep_conf[j],
|
|
imx_usb->base + USB_DDAT);
|
|
do {} while (__raw_readl(imx_usb->base
|
|
+ USB_DADR)
|
|
& DADR_BSY);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* wait CFG bit to clear */
|
|
do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG);
|
|
}
|
|
|
|
void imx_udc_init_irq(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int i;
|
|
|
|
/* Mask and clear all irqs */
|
|
__raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK);
|
|
__raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR);
|
|
for (i = 0; i < IMX_USB_NB_EP; i++) {
|
|
__raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i));
|
|
__raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i));
|
|
}
|
|
|
|
/* Enable USB irqs */
|
|
__raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK);
|
|
|
|
/* Enable EP0 irqs */
|
|
__raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT
|
|
| EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL),
|
|
imx_usb->base + USB_EP_MASK(0));
|
|
}
|
|
|
|
void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int i, max, temp;
|
|
struct imx_ep_struct *imx_ep;
|
|
for (i = 0; i < IMX_USB_NB_EP; i++) {
|
|
imx_ep = &imx_usb->imx_ep[i];
|
|
switch (imx_ep->fifosize) {
|
|
case 8:
|
|
max = 0;
|
|
break;
|
|
case 16:
|
|
max = 1;
|
|
break;
|
|
case 32:
|
|
max = 2;
|
|
break;
|
|
case 64:
|
|
max = 3;
|
|
break;
|
|
default:
|
|
max = 1;
|
|
break;
|
|
}
|
|
temp = (EP_DIR(imx_ep) << 7) | (max << 5)
|
|
| (imx_ep->bmAttributes << 3);
|
|
__raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
|
|
__raw_writel(temp | EPSTAT_FLUSH,
|
|
imx_usb->base + USB_EP_STAT(i));
|
|
D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
|
|
__raw_readl(imx_usb->base + USB_EP_STAT(i)));
|
|
}
|
|
}
|
|
|
|
void imx_udc_init_fifo(struct imx_udc_struct *imx_usb)
|
|
{
|
|
int i, temp;
|
|
struct imx_ep_struct *imx_ep;
|
|
for (i = 0; i < IMX_USB_NB_EP; i++) {
|
|
imx_ep = &imx_usb->imx_ep[i];
|
|
|
|
/* Fifo control */
|
|
temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000;
|
|
__raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i));
|
|
D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i,
|
|
__raw_readl(imx_usb->base + USB_EP_FCTRL(i)));
|
|
|
|
/* Fifo alarm */
|
|
temp = (i ? imx_ep->fifosize / 2 : 0);
|
|
__raw_writel(temp, imx_usb->base + USB_EP_FALRM(i));
|
|
D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i,
|
|
__raw_readl(imx_usb->base + USB_EP_FALRM(i)));
|
|
}
|
|
}
|
|
|
|
static void imx_udc_init(struct imx_udc_struct *imx_usb)
|
|
{
|
|
/* Reset UDC */
|
|
imx_udc_reset(imx_usb);
|
|
|
|
/* Download config to enpoint buffer */
|
|
imx_udc_config(imx_usb);
|
|
|
|
/* Setup interrups */
|
|
imx_udc_init_irq(imx_usb);
|
|
|
|
/* Setup endpoints */
|
|
imx_udc_init_ep(imx_usb);
|
|
|
|
/* Setup fifos */
|
|
imx_udc_init_fifo(imx_usb);
|
|
}
|
|
|
|
void imx_ep_irq_enable(struct imx_ep_struct *imx_ep)
|
|
{
|
|
|
|
int i = EP_NO(imx_ep);
|
|
|
|
__raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
|
|
__raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
|
|
__raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF),
|
|
imx_ep->imx_usb->base + USB_EP_MASK(i));
|
|
}
|
|
|
|
void imx_ep_irq_disable(struct imx_ep_struct *imx_ep)
|
|
{
|
|
|
|
int i = EP_NO(imx_ep);
|
|
|
|
__raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
|
|
__raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
|
|
}
|
|
|
|
int imx_ep_empty(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
|
|
|
|
return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
|
|
& FSTAT_EMPTY;
|
|
}
|
|
|
|
unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
|
|
|
|
return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)))
|
|
& EPSTAT_BCOUNT) >> 16;
|
|
}
|
|
|
|
void imx_flush(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
|
|
|
|
int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
|
|
__raw_writel(temp | EPSTAT_FLUSH,
|
|
imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
|
|
}
|
|
|
|
void imx_ep_stall(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
|
|
int temp, i;
|
|
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
|
|
|
|
imx_flush(imx_ep);
|
|
|
|
/* Special care for ep0 */
|
|
if (!EP_NO(imx_ep)) {
|
|
temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
__raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR,
|
|
imx_usb->base + USB_CTRL);
|
|
do { } while (__raw_readl(imx_usb->base + USB_CTRL)
|
|
& CTRL_CMDOVER);
|
|
temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
__raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
|
|
}
|
|
else {
|
|
temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
|
|
__raw_writel(temp | EPSTAT_STALL,
|
|
imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
|
|
|
|
for (i = 0; i < 100; i ++) {
|
|
temp = __raw_readl(imx_usb->base
|
|
+ USB_EP_STAT(EP_NO(imx_ep)));
|
|
if (!(temp & EPSTAT_STALL))
|
|
break;
|
|
udelay(20);
|
|
}
|
|
if (i == 100)
|
|
D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
|
|
__func__, imx_ep->ep.name);
|
|
}
|
|
}
|
|
|
|
static int imx_udc_get_frame(struct usb_gadget *_gadget)
|
|
{
|
|
struct imx_udc_struct *imx_usb = container_of(_gadget,
|
|
struct imx_udc_struct, gadget);
|
|
|
|
return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF;
|
|
}
|
|
|
|
static int imx_udc_wakeup(struct usb_gadget *_gadget)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* USB request control functions
|
|
*******************************************************************************
|
|
*/
|
|
|
|
static void ep_add_request(struct imx_ep_struct *imx_ep,
|
|
struct imx_request *req)
|
|
{
|
|
if (unlikely(!req))
|
|
return;
|
|
|
|
req->in_use = 1;
|
|
list_add_tail(&req->queue, &imx_ep->queue);
|
|
}
|
|
|
|
static void ep_del_request(struct imx_ep_struct *imx_ep,
|
|
struct imx_request *req)
|
|
{
|
|
if (unlikely(!req))
|
|
return;
|
|
|
|
list_del_init(&req->queue);
|
|
req->in_use = 0;
|
|
}
|
|
|
|
static void done(struct imx_ep_struct *imx_ep,
|
|
struct imx_request *req, int status)
|
|
{
|
|
ep_del_request(imx_ep, req);
|
|
|
|
if (likely(req->req.status == -EINPROGRESS))
|
|
req->req.status = status;
|
|
else
|
|
status = req->req.status;
|
|
|
|
if (status && status != -ESHUTDOWN)
|
|
D_ERR(imx_ep->imx_usb->dev,
|
|
"<%s> complete %s req %p stat %d len %u/%u\n", __func__,
|
|
imx_ep->ep.name, &req->req, status,
|
|
req->req.actual, req->req.length);
|
|
|
|
req->req.complete(&imx_ep->ep, &req->req);
|
|
}
|
|
|
|
static void nuke(struct imx_ep_struct *imx_ep, int status)
|
|
{
|
|
struct imx_request *req;
|
|
|
|
while (!list_empty(&imx_ep->queue)) {
|
|
req = list_entry(imx_ep->queue.next, struct imx_request, queue);
|
|
done(imx_ep, req, status);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Data tansfer over USB functions
|
|
*******************************************************************************
|
|
*/
|
|
static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
|
|
{
|
|
u8 *buf;
|
|
int bytes_ep, bufferspace, count, i;
|
|
|
|
bytes_ep = imx_fifo_bcount(imx_ep);
|
|
bufferspace = req->req.length - req->req.actual;
|
|
|
|
buf = req->req.buf + req->req.actual;
|
|
prefetchw(buf);
|
|
|
|
if (unlikely(imx_ep_empty(imx_ep)))
|
|
count = 0; /* zlp */
|
|
else
|
|
count = min(bytes_ep, bufferspace);
|
|
|
|
for (i = count; i > 0; i--)
|
|
*buf++ = __raw_readb(imx_ep->imx_usb->base
|
|
+ USB_EP_FDAT0(EP_NO(imx_ep)));
|
|
req->req.actual += count;
|
|
|
|
return count;
|
|
}
|
|
|
|
static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
|
|
{
|
|
u8 *buf;
|
|
int length, count, temp;
|
|
|
|
if (unlikely(__raw_readl(imx_ep->imx_usb->base +
|
|
USB_EP_STAT(EP_NO(imx_ep))) & EPSTAT_ZLPS)) {
|
|
D_TRX(imx_ep->imx_usb->dev, "<%s> zlp still queued in EP %s\n",
|
|
__func__, imx_ep->ep.name);
|
|
return -1;
|
|
}
|
|
|
|
buf = req->req.buf + req->req.actual;
|
|
prefetch(buf);
|
|
|
|
length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
|
|
|
|
if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
|
|
D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
|
|
__func__, imx_ep->ep.name);
|
|
return -1;
|
|
}
|
|
|
|
req->req.actual += length;
|
|
count = length;
|
|
|
|
if (!count && req->req.zero) { /* zlp */
|
|
temp = __raw_readl(imx_ep->imx_usb->base
|
|
+ USB_EP_STAT(EP_NO(imx_ep)));
|
|
__raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
|
|
+ USB_EP_STAT(EP_NO(imx_ep)));
|
|
D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
while (count--) {
|
|
if (count == 0) { /* last byte */
|
|
temp = __raw_readl(imx_ep->imx_usb->base
|
|
+ USB_EP_FCTRL(EP_NO(imx_ep)));
|
|
__raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
|
|
+ USB_EP_FCTRL(EP_NO(imx_ep)));
|
|
}
|
|
__raw_writeb(*buf++,
|
|
imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
|
|
{
|
|
int bytes = 0,
|
|
count,
|
|
completed = 0;
|
|
|
|
while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
|
|
& FSTAT_FR) {
|
|
count = read_packet(imx_ep, req);
|
|
bytes += count;
|
|
|
|
completed = (count != imx_ep->fifosize);
|
|
if (completed || req->req.actual == req->req.length) {
|
|
completed = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (completed || !req->req.length) {
|
|
done(imx_ep, req, 0);
|
|
D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
|
|
__func__, imx_ep->ep.name, req,
|
|
completed ? "completed" : "not completed");
|
|
if (!EP_NO(imx_ep))
|
|
ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
|
|
}
|
|
|
|
D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
|
|
|
|
return completed;
|
|
}
|
|
|
|
static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
|
|
{
|
|
int bytes = 0,
|
|
count,
|
|
completed = 0;
|
|
|
|
while (!completed) {
|
|
count = write_packet(imx_ep, req);
|
|
if (count < 0)
|
|
break; /* busy */
|
|
bytes += count;
|
|
|
|
/* last packet "must be" short (or a zlp) */
|
|
completed = (count != imx_ep->fifosize);
|
|
|
|
if (unlikely(completed)) {
|
|
done(imx_ep, req, 0);
|
|
D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
|
|
__func__, imx_ep->ep.name, req,
|
|
completed ? "completed" : "not completed");
|
|
if (!EP_NO(imx_ep))
|
|
ep0_chg_stat(__func__,
|
|
imx_ep->imx_usb, EP0_IDLE);
|
|
}
|
|
}
|
|
|
|
D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
|
|
|
|
return completed;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Endpoint handlers
|
|
*******************************************************************************
|
|
*/
|
|
static int handle_ep(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_request *req;
|
|
int completed = 0;
|
|
|
|
do {
|
|
if (!list_empty(&imx_ep->queue))
|
|
req = list_entry(imx_ep->queue.next,
|
|
struct imx_request, queue);
|
|
else {
|
|
D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
|
|
__func__, imx_ep->ep.name);
|
|
return 0;
|
|
}
|
|
|
|
if (EP_DIR(imx_ep)) /* to host */
|
|
completed = write_fifo(imx_ep, req);
|
|
else /* to device */
|
|
completed = read_fifo(imx_ep, req);
|
|
|
|
dump_ep_stat(__func__, imx_ep);
|
|
|
|
} while (completed);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int handle_ep0(struct imx_ep_struct *imx_ep)
|
|
{
|
|
struct imx_request *req = NULL;
|
|
int ret = 0;
|
|
|
|
if (!list_empty(&imx_ep->queue)) {
|
|
req = list_entry(imx_ep->queue.next, struct imx_request, queue);
|
|
|
|
switch (imx_ep->imx_usb->ep0state) {
|
|
|
|
case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR */
|
|
write_fifo(imx_ep, req);
|
|
break;
|
|
case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR */
|
|
read_fifo(imx_ep, req);
|
|
break;
|
|
default:
|
|
D_EP0(imx_ep->imx_usb->dev,
|
|
"<%s> ep0 i/o, odd state %d\n",
|
|
__func__, imx_ep->imx_usb->ep0state);
|
|
ep_del_request(imx_ep, req);
|
|
ret = -EL2HLT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
|
|
__func__, imx_ep->ep.name);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
|
|
{
|
|
struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
|
|
union {
|
|
struct usb_ctrlrequest r;
|
|
u8 raw[8];
|
|
u32 word[2];
|
|
} u;
|
|
int temp, i;
|
|
|
|
nuke(imx_ep, -EPROTO);
|
|
|
|
/* read SETUP packet */
|
|
for (i = 0; i < 2; i++) {
|
|
if (imx_ep_empty(imx_ep)) {
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> no setup packet received\n", __func__);
|
|
goto stall;
|
|
}
|
|
u.word[i] = __raw_readl(imx_usb->base
|
|
+ USB_EP_FDAT(EP_NO(imx_ep)));
|
|
}
|
|
|
|
temp = imx_ep_empty(imx_ep);
|
|
while (!imx_ep_empty(imx_ep)) {
|
|
i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> wrong to have extra bytes for setup : 0x%08x\n",
|
|
__func__, i);
|
|
}
|
|
if (!temp)
|
|
goto stall;
|
|
|
|
le16_to_cpus(&u.r.wValue);
|
|
le16_to_cpus(&u.r.wIndex);
|
|
le16_to_cpus(&u.r.wLength);
|
|
|
|
D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
|
|
__func__, u.r.bRequestType, u.r.bRequest,
|
|
u.r.wValue, u.r.wIndex, u.r.wLength);
|
|
|
|
if (imx_usb->set_config) {
|
|
/* NACK the host by using CMDOVER */
|
|
temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
__raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
|
|
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> set config req is pending, NACK the host\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
|
|
if (u.r.bRequestType & USB_DIR_IN)
|
|
ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
|
|
else
|
|
ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
|
|
|
|
i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
|
|
if (i < 0) {
|
|
D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
|
|
__func__, i);
|
|
goto stall;
|
|
}
|
|
|
|
return;
|
|
stall:
|
|
D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
|
|
imx_ep_stall(imx_ep);
|
|
ep0_chg_stat(__func__, imx_usb, EP0_STALL);
|
|
return;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* USB gadget callback functions
|
|
*******************************************************************************
|
|
*/
|
|
|
|
static int imx_ep_enable(struct usb_ep *usb_ep,
|
|
const struct usb_endpoint_descriptor *desc)
|
|
{
|
|
struct imx_ep_struct *imx_ep = container_of(usb_ep,
|
|
struct imx_ep_struct, ep);
|
|
struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
|
|
unsigned long flags;
|
|
|
|
if (!usb_ep
|
|
|| !desc
|
|
|| !EP_NO(imx_ep)
|
|
|| desc->bDescriptorType != USB_DT_ENDPOINT
|
|
|| imx_ep->bEndpointAddress != desc->bEndpointAddress) {
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> bad ep or descriptor\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (imx_ep->bmAttributes != desc->bmAttributes) {
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> %s type mismatch\n", __func__, usb_ep->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> bad %s maxpacket\n", __func__, usb_ep->name);
|
|
return -ERANGE;
|
|
}
|
|
|
|
if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
|
|
D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
|
|
return -ESHUTDOWN;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
|
|
imx_ep->stopped = 0;
|
|
imx_flush(imx_ep);
|
|
imx_ep_irq_enable(imx_ep);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
|
|
return 0;
|
|
}
|
|
|
|
static int imx_ep_disable(struct usb_ep *usb_ep)
|
|
{
|
|
struct imx_ep_struct *imx_ep = container_of(usb_ep,
|
|
struct imx_ep_struct, ep);
|
|
unsigned long flags;
|
|
|
|
if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
|
|
__func__, usb_ep ? imx_ep->ep.name : NULL);
|
|
return -EINVAL;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
|
|
imx_ep->stopped = 1;
|
|
nuke(imx_ep, -ESHUTDOWN);
|
|
imx_flush(imx_ep);
|
|
imx_ep_irq_disable(imx_ep);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
D_EPX(imx_ep->imx_usb->dev,
|
|
"<%s> DISABLED %s\n", __func__, usb_ep->name);
|
|
return 0;
|
|
}
|
|
|
|
static struct usb_request *imx_ep_alloc_request
|
|
(struct usb_ep *usb_ep, gfp_t gfp_flags)
|
|
{
|
|
struct imx_request *req;
|
|
|
|
if (!usb_ep)
|
|
return NULL;
|
|
|
|
req = kzalloc(sizeof *req, gfp_flags);
|
|
if (!req)
|
|
return NULL;
|
|
|
|
INIT_LIST_HEAD(&req->queue);
|
|
req->in_use = 0;
|
|
|
|
return &req->req;
|
|
}
|
|
|
|
static void imx_ep_free_request
|
|
(struct usb_ep *usb_ep, struct usb_request *usb_req)
|
|
{
|
|
struct imx_request *req;
|
|
|
|
req = container_of(usb_req, struct imx_request, req);
|
|
WARN_ON(!list_empty(&req->queue));
|
|
kfree(req);
|
|
}
|
|
|
|
static int imx_ep_queue
|
|
(struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
|
|
{
|
|
struct imx_ep_struct *imx_ep;
|
|
struct imx_udc_struct *imx_usb;
|
|
struct imx_request *req;
|
|
unsigned long flags;
|
|
int ret = 0;
|
|
|
|
imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
|
|
imx_usb = imx_ep->imx_usb;
|
|
req = container_of(usb_req, struct imx_request, req);
|
|
|
|
/*
|
|
Special care on IMX udc.
|
|
Ignore enqueue when after set configuration from the
|
|
host. This assume all gadget drivers reply set
|
|
configuration with the next ep0 req enqueue.
|
|
*/
|
|
if (imx_usb->set_config && !EP_NO(imx_ep)) {
|
|
imx_usb->set_config = 0;
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> gadget reply set config\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
|
|
D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (unlikely(!usb_ep || !imx_ep)) {
|
|
D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
|
|
D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
|
|
return -ESHUTDOWN;
|
|
}
|
|
|
|
/* Debug */
|
|
D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
|
|
__func__, EP_NO(imx_ep),
|
|
((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
|
|
== EP0_IN_DATA_PHASE)
|
|
|| (EP_NO(imx_ep) && EP_DIR(imx_ep)))
|
|
? "IN" : "OUT", usb_req->length);
|
|
dump_req(__func__, imx_ep, usb_req);
|
|
|
|
if (imx_ep->stopped) {
|
|
usb_req->status = -ESHUTDOWN;
|
|
return -ESHUTDOWN;
|
|
}
|
|
|
|
if (req->in_use) {
|
|
D_ERR(imx_usb->dev,
|
|
"<%s> refusing to queue req %p (already queued)\n",
|
|
__func__, req);
|
|
return 0;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
|
|
usb_req->status = -EINPROGRESS;
|
|
usb_req->actual = 0;
|
|
|
|
ep_add_request(imx_ep, req);
|
|
|
|
if (!EP_NO(imx_ep))
|
|
ret = handle_ep0(imx_ep);
|
|
else
|
|
ret = handle_ep(imx_ep);
|
|
|
|
local_irq_restore(flags);
|
|
return ret;
|
|
}
|
|
|
|
static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
|
|
{
|
|
|
|
struct imx_ep_struct *imx_ep = container_of
|
|
(usb_ep, struct imx_ep_struct, ep);
|
|
struct imx_request *req;
|
|
unsigned long flags;
|
|
|
|
if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
|
|
/* make sure it's actually queued on this endpoint */
|
|
list_for_each_entry(req, &imx_ep->queue, queue) {
|
|
if (&req->req == usb_req)
|
|
break;
|
|
}
|
|
if (&req->req != usb_req) {
|
|
local_irq_restore(flags);
|
|
return -EINVAL;
|
|
}
|
|
|
|
done(imx_ep, req, -ECONNRESET);
|
|
|
|
local_irq_restore(flags);
|
|
return 0;
|
|
}
|
|
|
|
static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
|
|
{
|
|
struct imx_ep_struct *imx_ep = container_of
|
|
(usb_ep, struct imx_ep_struct, ep);
|
|
unsigned long flags;
|
|
|
|
if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
|
|
if ((imx_ep->bEndpointAddress & USB_DIR_IN)
|
|
&& !list_empty(&imx_ep->queue)) {
|
|
local_irq_restore(flags);
|
|
return -EAGAIN;
|
|
}
|
|
|
|
imx_ep_stall(imx_ep);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
|
|
return 0;
|
|
}
|
|
|
|
static int imx_ep_fifo_status(struct usb_ep *usb_ep)
|
|
{
|
|
struct imx_ep_struct *imx_ep = container_of
|
|
(usb_ep, struct imx_ep_struct, ep);
|
|
|
|
if (!usb_ep) {
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
|
|
return 0;
|
|
else
|
|
return imx_fifo_bcount(imx_ep);
|
|
}
|
|
|
|
static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
|
|
{
|
|
struct imx_ep_struct *imx_ep = container_of
|
|
(usb_ep, struct imx_ep_struct, ep);
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
|
|
if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
|
|
D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
|
|
local_irq_restore(flags);
|
|
return;
|
|
}
|
|
|
|
/* toggle and halt bits stay unchanged */
|
|
imx_flush(imx_ep);
|
|
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
static struct usb_ep_ops imx_ep_ops = {
|
|
.enable = imx_ep_enable,
|
|
.disable = imx_ep_disable,
|
|
|
|
.alloc_request = imx_ep_alloc_request,
|
|
.free_request = imx_ep_free_request,
|
|
|
|
.queue = imx_ep_queue,
|
|
.dequeue = imx_ep_dequeue,
|
|
|
|
.set_halt = imx_ep_set_halt,
|
|
.fifo_status = imx_ep_fifo_status,
|
|
.fifo_flush = imx_ep_fifo_flush,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* USB endpoint control functions
|
|
*******************************************************************************
|
|
*/
|
|
|
|
void ep0_chg_stat(const char *label,
|
|
struct imx_udc_struct *imx_usb, enum ep0_state stat)
|
|
{
|
|
D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
|
|
label, state_name[imx_usb->ep0state], state_name[stat]);
|
|
|
|
if (imx_usb->ep0state == stat)
|
|
return;
|
|
|
|
imx_usb->ep0state = stat;
|
|
}
|
|
|
|
static void usb_init_data(struct imx_udc_struct *imx_usb)
|
|
{
|
|
struct imx_ep_struct *imx_ep;
|
|
u8 i;
|
|
|
|
/* device/ep0 records init */
|
|
INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
|
|
INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
|
|
ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
|
|
|
|
/* basic endpoint records init */
|
|
for (i = 0; i < IMX_USB_NB_EP; i++) {
|
|
imx_ep = &imx_usb->imx_ep[i];
|
|
|
|
if (i) {
|
|
list_add_tail(&imx_ep->ep.ep_list,
|
|
&imx_usb->gadget.ep_list);
|
|
imx_ep->stopped = 1;
|
|
} else
|
|
imx_ep->stopped = 0;
|
|
|
|
INIT_LIST_HEAD(&imx_ep->queue);
|
|
}
|
|
}
|
|
|
|
static void udc_stop_activity(struct imx_udc_struct *imx_usb,
|
|
struct usb_gadget_driver *driver)
|
|
{
|
|
struct imx_ep_struct *imx_ep;
|
|
int i;
|
|
|
|
if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
|
|
driver = NULL;
|
|
|
|
/* prevent new request submissions, kill any outstanding requests */
|
|
for (i = 1; i < IMX_USB_NB_EP; i++) {
|
|
imx_ep = &imx_usb->imx_ep[i];
|
|
imx_flush(imx_ep);
|
|
imx_ep->stopped = 1;
|
|
imx_ep_irq_disable(imx_ep);
|
|
nuke(imx_ep, -ESHUTDOWN);
|
|
}
|
|
|
|
imx_usb->cfg = 0;
|
|
imx_usb->intf = 0;
|
|
imx_usb->alt = 0;
|
|
|
|
if (driver)
|
|
driver->disconnect(&imx_usb->gadget);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Interrupt handlers
|
|
*******************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* Called when timer expires.
|
|
* Timer is started when CFG_CHG is received.
|
|
*/
|
|
static void handle_config(unsigned long data)
|
|
{
|
|
struct imx_udc_struct *imx_usb = (void *)data;
|
|
struct usb_ctrlrequest u;
|
|
int temp, cfg, intf, alt;
|
|
|
|
local_irq_disable();
|
|
|
|
temp = __raw_readl(imx_usb->base + USB_STAT);
|
|
cfg = (temp & STAT_CFG) >> 5;
|
|
intf = (temp & STAT_INTF) >> 3;
|
|
alt = temp & STAT_ALTSET;
|
|
|
|
D_REQ(imx_usb->dev,
|
|
"<%s> orig config C=%d, I=%d, A=%d / "
|
|
"req config C=%d, I=%d, A=%d\n",
|
|
__func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
|
|
cfg, intf, alt);
|
|
|
|
if (cfg == 1 || cfg == 2) {
|
|
|
|
if (imx_usb->cfg != cfg) {
|
|
u.bRequest = USB_REQ_SET_CONFIGURATION;
|
|
u.bRequestType = USB_DIR_OUT |
|
|
USB_TYPE_STANDARD |
|
|
USB_RECIP_DEVICE;
|
|
u.wValue = cfg;
|
|
u.wIndex = 0;
|
|
u.wLength = 0;
|
|
imx_usb->cfg = cfg;
|
|
imx_usb->driver->setup(&imx_usb->gadget, &u);
|
|
|
|
}
|
|
if (imx_usb->intf != intf || imx_usb->alt != alt) {
|
|
u.bRequest = USB_REQ_SET_INTERFACE;
|
|
u.bRequestType = USB_DIR_OUT |
|
|
USB_TYPE_STANDARD |
|
|
USB_RECIP_INTERFACE;
|
|
u.wValue = alt;
|
|
u.wIndex = intf;
|
|
u.wLength = 0;
|
|
imx_usb->intf = intf;
|
|
imx_usb->alt = alt;
|
|
imx_usb->driver->setup(&imx_usb->gadget, &u);
|
|
}
|
|
}
|
|
|
|
imx_usb->set_config = 0;
|
|
|
|
local_irq_enable();
|
|
}
|
|
|
|
static irqreturn_t imx_udc_irq(int irq, void *dev)
|
|
{
|
|
struct imx_udc_struct *imx_usb = dev;
|
|
int intr = __raw_readl(imx_usb->base + USB_INTR);
|
|
int temp;
|
|
|
|
if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
|
|
| INTR_RESET_STOP | INTR_CFG_CHG)) {
|
|
dump_intr(__func__, intr, imx_usb->dev);
|
|
dump_usb_stat(__func__, imx_usb);
|
|
}
|
|
|
|
if (!imx_usb->driver)
|
|
goto end_irq;
|
|
|
|
if (intr & INTR_SOF) {
|
|
/* Copy from Freescale BSP.
|
|
We must enable SOF intr and set CMDOVER.
|
|
Datasheet don't specifiy this action, but it
|
|
is done in Freescale BSP, so just copy it.
|
|
*/
|
|
if (imx_usb->ep0state == EP0_IDLE) {
|
|
temp = __raw_readl(imx_usb->base + USB_CTRL);
|
|
__raw_writel(temp | CTRL_CMDOVER,
|
|
imx_usb->base + USB_CTRL);
|
|
}
|
|
}
|
|
|
|
if (intr & INTR_CFG_CHG) {
|
|
/* A workaround of serious IMX UDC bug.
|
|
Handling of CFG_CHG should be delayed for some time, because
|
|
IMX does not NACK the host when CFG_CHG interrupt is pending.
|
|
There is no time to handle current CFG_CHG
|
|
if next CFG_CHG or SETUP packed is send immediately.
|
|
We have to clear CFG_CHG, start the timer and
|
|
NACK the host by setting CTRL_CMDOVER
|
|
if it sends any SETUP packet.
|
|
When timer expires, handler is called to handle configuration
|
|
changes. While CFG_CHG is not handled (set_config=1),
|
|
we must NACK the host to every SETUP packed.
|
|
This delay prevents from going out of sync with host.
|
|
*/
|
|
__raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
|
|
imx_usb->set_config = 1;
|
|
mod_timer(&imx_usb->timer, jiffies + 5);
|
|
goto end_irq;
|
|
}
|
|
|
|
if (intr & INTR_WAKEUP) {
|
|
if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
|
|
&& imx_usb->driver && imx_usb->driver->resume)
|
|
imx_usb->driver->resume(&imx_usb->gadget);
|
|
imx_usb->set_config = 0;
|
|
del_timer(&imx_usb->timer);
|
|
imx_usb->gadget.speed = USB_SPEED_FULL;
|
|
}
|
|
|
|
if (intr & INTR_SUSPEND) {
|
|
if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
|
|
&& imx_usb->driver && imx_usb->driver->suspend)
|
|
imx_usb->driver->suspend(&imx_usb->gadget);
|
|
imx_usb->set_config = 0;
|
|
del_timer(&imx_usb->timer);
|
|
imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
|
|
}
|
|
|
|
if (intr & INTR_RESET_START) {
|
|
__raw_writel(intr, imx_usb->base + USB_INTR);
|
|
udc_stop_activity(imx_usb, imx_usb->driver);
|
|
imx_usb->set_config = 0;
|
|
del_timer(&imx_usb->timer);
|
|
imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
|
|
}
|
|
|
|
if (intr & INTR_RESET_STOP)
|
|
imx_usb->gadget.speed = USB_SPEED_FULL;
|
|
|
|
end_irq:
|
|
__raw_writel(intr, imx_usb->base + USB_INTR);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
|
|
{
|
|
struct imx_udc_struct *imx_usb = dev;
|
|
struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
|
|
int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
|
|
|
|
dump_ep_intr(__func__, 0, intr, imx_usb->dev);
|
|
|
|
if (!imx_usb->driver) {
|
|
__raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/* DEVREQ has highest priority */
|
|
if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
|
|
handle_ep0_devreq(imx_usb);
|
|
/* Seem i.MX is missing EOF interrupt sometimes.
|
|
* Therefore we don't monitor EOF.
|
|
* We call handle_ep0() only if a request is queued for ep0.
|
|
*/
|
|
else if (!list_empty(&imx_ep->queue))
|
|
handle_ep0(imx_ep);
|
|
|
|
__raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
|
|
{
|
|
struct imx_udc_struct *imx_usb = dev;
|
|
struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
|
|
int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
|
|
|
|
dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
|
|
|
|
if (!imx_usb->driver) {
|
|
__raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
handle_ep(imx_ep);
|
|
|
|
__raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
irq_handler_t intr_handler(int i)
|
|
{
|
|
switch (i) {
|
|
case 0:
|
|
return imx_udc_ctrl_irq;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
return imx_udc_bulk_irq;
|
|
default:
|
|
return imx_udc_irq;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* Static defined IMX UDC structure
|
|
*******************************************************************************
|
|
*/
|
|
|
|
static const struct usb_gadget_ops imx_udc_ops = {
|
|
.get_frame = imx_udc_get_frame,
|
|
.wakeup = imx_udc_wakeup,
|
|
};
|
|
|
|
static struct imx_udc_struct controller = {
|
|
.gadget = {
|
|
.ops = &imx_udc_ops,
|
|
.ep0 = &controller.imx_ep[0].ep,
|
|
.name = driver_name,
|
|
.dev = {
|
|
.init_name = "gadget",
|
|
},
|
|
},
|
|
|
|
.imx_ep[0] = {
|
|
.ep = {
|
|
.name = ep0name,
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 32,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 32,
|
|
.bEndpointAddress = 0,
|
|
.bmAttributes = USB_ENDPOINT_XFER_CONTROL,
|
|
},
|
|
.imx_ep[1] = {
|
|
.ep = {
|
|
.name = "ep1in-bulk",
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 64,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 64,
|
|
.bEndpointAddress = USB_DIR_IN | 1,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
},
|
|
.imx_ep[2] = {
|
|
.ep = {
|
|
.name = "ep2out-bulk",
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 64,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 64,
|
|
.bEndpointAddress = USB_DIR_OUT | 2,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
},
|
|
.imx_ep[3] = {
|
|
.ep = {
|
|
.name = "ep3out-bulk",
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 32,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 32,
|
|
.bEndpointAddress = USB_DIR_OUT | 3,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
},
|
|
.imx_ep[4] = {
|
|
.ep = {
|
|
.name = "ep4in-int",
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 32,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 32,
|
|
.bEndpointAddress = USB_DIR_IN | 4,
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
},
|
|
.imx_ep[5] = {
|
|
.ep = {
|
|
.name = "ep5out-int",
|
|
.ops = &imx_ep_ops,
|
|
.maxpacket = 32,
|
|
},
|
|
.imx_usb = &controller,
|
|
.fifosize = 32,
|
|
.bEndpointAddress = USB_DIR_OUT | 5,
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
},
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* USB gadged driver functions
|
|
*******************************************************************************
|
|
*/
|
|
int usb_gadget_register_driver(struct usb_gadget_driver *driver)
|
|
{
|
|
struct imx_udc_struct *imx_usb = &controller;
|
|
int retval;
|
|
|
|
if (!driver
|
|
|| driver->speed < USB_SPEED_FULL
|
|
|| !driver->bind
|
|
|| !driver->disconnect
|
|
|| !driver->setup)
|
|
return -EINVAL;
|
|
if (!imx_usb)
|
|
return -ENODEV;
|
|
if (imx_usb->driver)
|
|
return -EBUSY;
|
|
|
|
/* first hook up the driver ... */
|
|
imx_usb->driver = driver;
|
|
imx_usb->gadget.dev.driver = &driver->driver;
|
|
|
|
retval = device_add(&imx_usb->gadget.dev);
|
|
if (retval)
|
|
goto fail;
|
|
retval = driver->bind(&imx_usb->gadget);
|
|
if (retval) {
|
|
D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
|
|
__func__, driver->driver.name, retval);
|
|
device_del(&imx_usb->gadget.dev);
|
|
|
|
goto fail;
|
|
}
|
|
|
|
D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
|
|
__func__, driver->driver.name);
|
|
|
|
imx_udc_enable(imx_usb);
|
|
|
|
return 0;
|
|
fail:
|
|
imx_usb->driver = NULL;
|
|
imx_usb->gadget.dev.driver = NULL;
|
|
return retval;
|
|
}
|
|
EXPORT_SYMBOL(usb_gadget_register_driver);
|
|
|
|
int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
|
|
{
|
|
struct imx_udc_struct *imx_usb = &controller;
|
|
|
|
if (!imx_usb)
|
|
return -ENODEV;
|
|
if (!driver || driver != imx_usb->driver || !driver->unbind)
|
|
return -EINVAL;
|
|
|
|
udc_stop_activity(imx_usb, driver);
|
|
imx_udc_disable(imx_usb);
|
|
del_timer(&imx_usb->timer);
|
|
|
|
driver->unbind(&imx_usb->gadget);
|
|
imx_usb->gadget.dev.driver = NULL;
|
|
imx_usb->driver = NULL;
|
|
|
|
device_del(&imx_usb->gadget.dev);
|
|
|
|
D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
|
|
__func__, driver->driver.name);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(usb_gadget_unregister_driver);
|
|
|
|
/*******************************************************************************
|
|
* Module functions
|
|
*******************************************************************************
|
|
*/
|
|
|
|
static int __init imx_udc_probe(struct platform_device *pdev)
|
|
{
|
|
struct imx_udc_struct *imx_usb = &controller;
|
|
struct resource *res;
|
|
struct imxusb_platform_data *pdata;
|
|
struct clk *clk;
|
|
void __iomem *base;
|
|
int ret = 0;
|
|
int i;
|
|
resource_size_t res_size;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
if (!res) {
|
|
dev_err(&pdev->dev, "can't get device resources\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
pdata = pdev->dev.platform_data;
|
|
if (!pdata) {
|
|
dev_err(&pdev->dev, "driver needs platform data\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
res_size = resource_size(res);
|
|
if (!request_mem_region(res->start, res_size, res->name)) {
|
|
dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
|
|
res_size, res->start);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (pdata->init) {
|
|
ret = pdata->init(&pdev->dev);
|
|
if (ret)
|
|
goto fail0;
|
|
}
|
|
|
|
base = ioremap(res->start, res_size);
|
|
if (!base) {
|
|
dev_err(&pdev->dev, "ioremap failed\n");
|
|
ret = -EIO;
|
|
goto fail1;
|
|
}
|
|
|
|
clk = clk_get(NULL, "usbd_clk");
|
|
if (IS_ERR(clk)) {
|
|
ret = PTR_ERR(clk);
|
|
dev_err(&pdev->dev, "can't get USB clock\n");
|
|
goto fail2;
|
|
}
|
|
clk_enable(clk);
|
|
|
|
if (clk_get_rate(clk) != 48000000) {
|
|
D_INI(&pdev->dev,
|
|
"Bad USB clock (%d Hz), changing to 48000000 Hz\n",
|
|
(int)clk_get_rate(clk));
|
|
if (clk_set_rate(clk, 48000000)) {
|
|
dev_err(&pdev->dev,
|
|
"Unable to set correct USB clock (48MHz)\n");
|
|
ret = -EIO;
|
|
goto fail3;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
|
|
imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
|
|
if (imx_usb->usbd_int[i] < 0) {
|
|
dev_err(&pdev->dev, "can't get irq number\n");
|
|
ret = -ENODEV;
|
|
goto fail3;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
|
|
ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
|
|
IRQF_DISABLED, driver_name, imx_usb);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "can't get irq %i, err %d\n",
|
|
imx_usb->usbd_int[i], ret);
|
|
for (--i; i >= 0; i--)
|
|
free_irq(imx_usb->usbd_int[i], imx_usb);
|
|
goto fail3;
|
|
}
|
|
}
|
|
|
|
imx_usb->res = res;
|
|
imx_usb->base = base;
|
|
imx_usb->clk = clk;
|
|
imx_usb->dev = &pdev->dev;
|
|
|
|
device_initialize(&imx_usb->gadget.dev);
|
|
|
|
imx_usb->gadget.dev.parent = &pdev->dev;
|
|
imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
|
|
|
|
platform_set_drvdata(pdev, imx_usb);
|
|
|
|
usb_init_data(imx_usb);
|
|
imx_udc_init(imx_usb);
|
|
|
|
init_timer(&imx_usb->timer);
|
|
imx_usb->timer.function = handle_config;
|
|
imx_usb->timer.data = (unsigned long)imx_usb;
|
|
|
|
return 0;
|
|
|
|
fail3:
|
|
clk_put(clk);
|
|
clk_disable(clk);
|
|
fail2:
|
|
iounmap(base);
|
|
fail1:
|
|
if (pdata->exit)
|
|
pdata->exit(&pdev->dev);
|
|
fail0:
|
|
release_mem_region(res->start, res_size);
|
|
return ret;
|
|
}
|
|
|
|
static int __exit imx_udc_remove(struct platform_device *pdev)
|
|
{
|
|
struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
|
|
struct imxusb_platform_data *pdata = pdev->dev.platform_data;
|
|
int i;
|
|
|
|
imx_udc_disable(imx_usb);
|
|
del_timer(&imx_usb->timer);
|
|
|
|
for (i = 0; i < IMX_USB_NB_EP + 1; i++)
|
|
free_irq(imx_usb->usbd_int[i], imx_usb);
|
|
|
|
clk_put(imx_usb->clk);
|
|
clk_disable(imx_usb->clk);
|
|
iounmap(imx_usb->base);
|
|
|
|
release_mem_region(imx_usb->res->start, resource_size(imx_usb->res));
|
|
|
|
if (pdata->exit)
|
|
pdata->exit(&pdev->dev);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
#ifdef CONFIG_PM
|
|
#define imx_udc_suspend NULL
|
|
#define imx_udc_resume NULL
|
|
#else
|
|
#define imx_udc_suspend NULL
|
|
#define imx_udc_resume NULL
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
static struct platform_driver udc_driver = {
|
|
.driver = {
|
|
.name = driver_name,
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.remove = __exit_p(imx_udc_remove),
|
|
.suspend = imx_udc_suspend,
|
|
.resume = imx_udc_resume,
|
|
};
|
|
|
|
static int __init udc_init(void)
|
|
{
|
|
return platform_driver_probe(&udc_driver, imx_udc_probe);
|
|
}
|
|
module_init(udc_init);
|
|
|
|
static void __exit udc_exit(void)
|
|
{
|
|
platform_driver_unregister(&udc_driver);
|
|
}
|
|
module_exit(udc_exit);
|
|
|
|
MODULE_DESCRIPTION("IMX USB Device Controller driver");
|
|
MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("platform:imx_udc");
|