git.oblomov.eu Git - linux-2.6/blob - drivers/usb/gadget/imx_udc.c

   1 /*
   2  *      driver/usb/gadget/imx_udc.c
   3  *
   4  *      Copyright (C) 2005 Mike Lee <eemike@gmail.com>
   5  *      Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  */
  17
  18 #include <linux/init.h>
  19 #include <linux/kernel.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/module.h>
  22 #include <linux/errno.h>
  23 #include <linux/list.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/io.h>
  26 #include <linux/irq.h>
  27 #include <linux/device.h>
  28 #include <linux/dma-mapping.h>
  29 #include <linux/clk.h>
  30 #include <linux/delay.h>
  31 #include <linux/timer.h>
  32
  33 #include <linux/usb/ch9.h>
  34 #include <linux/usb/gadget.h>
  35
  36 #include <mach/usb.h>
  37 #include <mach/hardware.h>
  38
  39 #include "imx_udc.h"
  40
  41 static const char driver_name[] = "imx_udc";
  42 static const char ep0name[] = "ep0";
  43
  44 void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
  45                                                         enum ep0_state stat);
  46
  47 /*******************************************************************************
  48  * IMX UDC hardware related functions
  49  *******************************************************************************
  50  */
  51
  52 void imx_udc_enable(struct imx_udc_struct *imx_usb)
  53 {
  54         int temp = __raw_readl(imx_usb->base + USB_CTRL);
  55         __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA,
  56                                                 imx_usb->base + USB_CTRL);
  57         imx_usb->gadget.speed = USB_SPEED_FULL;
  58 }
  59
  60 void imx_udc_disable(struct imx_udc_struct *imx_usb)
  61 {
  62         int temp = __raw_readl(imx_usb->base + USB_CTRL);
  63
  64         __raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA),
  65                  imx_usb->base + USB_CTRL);
  66
  67         ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
  68         imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
  69 }
  70
  71 void imx_udc_reset(struct imx_udc_struct *imx_usb)
  72 {
  73         int temp = __raw_readl(imx_usb->base + USB_ENAB);
  74
  75         /* set RST bit */
  76         __raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB);
  77
  78         /* wait RST bit to clear */
  79         do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST);
  80
  81         /* wait CFG bit to assert */
  82         do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
  83
  84         /* udc module is now ready */
  85 }
  86
  87 void imx_udc_config(struct imx_udc_struct *imx_usb)
  88 {
  89         u8 ep_conf[5];
  90         u8 i, j, cfg;
  91         struct imx_ep_struct *imx_ep;
  92
  93         /* wait CFG bit to assert */
  94         do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
  95
  96         /* Download the endpoint buffer for endpoint 0. */
  97         for (j = 0; j < 5; j++) {
  98                 i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00);
  99                 __raw_writeb(i, imx_usb->base + USB_DDAT);
 100                 do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY);
 101         }
 102
 103         /* Download the endpoint buffers for endpoints 1-5.
 104          * We specify two configurations, one interface
 105          */
 106         for (cfg = 1; cfg < 3; cfg++) {
 107                 for (i = 1; i < IMX_USB_NB_EP; i++) {
 108                         imx_ep = &imx_usb->imx_ep[i];
 109                         /* EP no | Config no */
 110                         ep_conf[0] = (i << 4) | (cfg << 2);
 111                         /* Type | Direction */
 112                         ep_conf[1] = (imx_ep->bmAttributes << 3) |
 113                                         (EP_DIR(imx_ep) << 2);
 114                         /* Max packet size */
 115                         ep_conf[2] = imx_ep->fifosize;
 116                         /* TRXTYP */
 117                         ep_conf[3] = 0xC0;
 118                         /* FIFO no */
 119                         ep_conf[4] = i;
 120
 121                         D_INI(imx_usb->dev,
 122                                 "<%s> ep%d_conf[%d]:"
 123                                 "[%02x-%02x-%02x-%02x-%02x]\n",
 124                                 __func__, i, cfg,
 125                                 ep_conf[0], ep_conf[1], ep_conf[2],
 126                                 ep_conf[3], ep_conf[4]);
 127
 128                         for (j = 0; j < 5; j++) {
 129                                 __raw_writeb(ep_conf[j],
 130                                         imx_usb->base + USB_DDAT);
 131                                 do {} while (__raw_readl(imx_usb->base
 132                                                                 + USB_DADR)
 133                                         & DADR_BSY);
 134                         }
 135                 }
 136         }
 137
 138         /* wait CFG bit to clear */
 139         do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG);
 140 }
 141
 142 void imx_udc_init_irq(struct imx_udc_struct *imx_usb)
 143 {
 144         int i;
 145
 146         /* Mask and clear all irqs */
 147         __raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK);
 148         __raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR);
 149         for (i = 0; i < IMX_USB_NB_EP; i++) {
 150                 __raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i));
 151                 __raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i));
 152         }
 153
 154         /* Enable USB irqs */
 155         __raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK);
 156
 157         /* Enable EP0 irqs */
 158         __raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT
 159                 | EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL),
 160                 imx_usb->base + USB_EP_MASK(0));
 161 }
 162
 163 void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
 164 {
 165         int i, max, temp;
 166         struct imx_ep_struct *imx_ep;
 167         for (i = 0; i < IMX_USB_NB_EP; i++) {
 168                 imx_ep = &imx_usb->imx_ep[i];
 169                 switch (imx_ep->fifosize) {
 170                 case 8:
 171                         max = 0;
 172                         break;
 173                 case 16:
 174                         max = 1;
 175                         break;
 176                 case 32:
 177                         max = 2;
 178                         break;
 179                 case 64:
 180                         max = 3;
 181                         break;
 182                 default:
 183                         max = 1;
 184                         break;
 185                 }
 186                 temp = (EP_DIR(imx_ep) << 7) | (max << 5)
 187                         | (imx_ep->bmAttributes << 3);
 188                 __raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
 189                 __raw_writel(temp | EPSTAT_FLUSH,
 190                                                 imx_usb->base + USB_EP_STAT(i));
 191                 D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
 192                         __raw_readl(imx_usb->base + USB_EP_STAT(i)));
 193         }
 194 }
 195
 196 void imx_udc_init_fifo(struct imx_udc_struct *imx_usb)
 197 {
 198         int i, temp;
 199         struct imx_ep_struct *imx_ep;
 200         for (i = 0; i < IMX_USB_NB_EP; i++) {
 201                 imx_ep = &imx_usb->imx_ep[i];
 202
 203                 /* Fifo control */
 204                 temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000;
 205                 __raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i));
 206                 D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i,
 207                         __raw_readl(imx_usb->base + USB_EP_FCTRL(i)));
 208
 209                 /* Fifo alarm */
 210                 temp = (i ? imx_ep->fifosize / 2 : 0);
 211                 __raw_writel(temp, imx_usb->base + USB_EP_FALRM(i));
 212                 D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i,
 213                         __raw_readl(imx_usb->base + USB_EP_FALRM(i)));
 214         }
 215 }
 216
 217 static void imx_udc_init(struct imx_udc_struct *imx_usb)
 218 {
 219         /* Reset UDC */
 220         imx_udc_reset(imx_usb);
 221
 222         /* Download config to enpoint buffer */
 223         imx_udc_config(imx_usb);
 224
 225         /* Setup interrups */
 226         imx_udc_init_irq(imx_usb);
 227
 228         /* Setup endpoints */
 229         imx_udc_init_ep(imx_usb);
 230
 231         /* Setup fifos */
 232         imx_udc_init_fifo(imx_usb);
 233 }
 234
 235 void imx_ep_irq_enable(struct imx_ep_struct *imx_ep)
 236 {
 237
 238         int i = EP_NO(imx_ep);
 239
 240         __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
 241         __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
 242         __raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF),
 243                 imx_ep->imx_usb->base + USB_EP_MASK(i));
 244 }
 245
 246 void imx_ep_irq_disable(struct imx_ep_struct *imx_ep)
 247 {
 248
 249         int i = EP_NO(imx_ep);
 250
 251         __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
 252         __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
 253 }
 254
 255 int imx_ep_empty(struct imx_ep_struct *imx_ep)
 256 {
 257         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 258
 259         return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
 260                         & FSTAT_EMPTY;
 261 }
 262
 263 unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep)
 264 {
 265         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 266
 267         return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)))
 268                         & EPSTAT_BCOUNT) >> 16;
 269 }
 270
 271 void imx_flush(struct imx_ep_struct *imx_ep)
 272 {
 273         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 274
 275         int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
 276         __raw_writel(temp | EPSTAT_FLUSH,
 277                 imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
 278 }
 279
 280 void imx_ep_stall(struct imx_ep_struct *imx_ep)
 281 {
 282         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 283         int temp, i;
 284
 285         D_ERR(imx_usb->dev,
 286                 "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
 287
 288         imx_flush(imx_ep);
 289
 290         /* Special care for ep0 */
 291         if (!EP_NO(imx_ep)) {
 292                 temp = __raw_readl(imx_usb->base + USB_CTRL);
 293                 __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR,
 294                                                 imx_usb->base + USB_CTRL);
 295                 do { } while (__raw_readl(imx_usb->base + USB_CTRL)
 296                                                 & CTRL_CMDOVER);
 297                 temp = __raw_readl(imx_usb->base + USB_CTRL);
 298                 __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
 299         }
 300         else {
 301                 temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
 302                 __raw_writel(temp | EPSTAT_STALL,
 303                         imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
 304
 305                 for (i = 0; i < 100; i ++) {
 306                         temp = __raw_readl(imx_usb->base
 307                                                 + USB_EP_STAT(EP_NO(imx_ep)));
 308                         if (!(temp & EPSTAT_STALL))
 309                                 break;
 310                         udelay(20);
 311                 }
 312                 if (i == 100)
 313                         D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
 314                                 __func__, imx_ep->ep.name);
 315         }
 316 }
 317
 318 static int imx_udc_get_frame(struct usb_gadget *_gadget)
 319 {
 320         struct imx_udc_struct *imx_usb = container_of(_gadget,
 321                         struct imx_udc_struct, gadget);
 322
 323         return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF;
 324 }
 325
 326 static int imx_udc_wakeup(struct usb_gadget *_gadget)
 327 {
 328         return 0;
 329 }
 330
 331 /*******************************************************************************
 332  * USB request control functions
 333  *******************************************************************************
 334  */
 335
 336 static void ep_add_request(struct imx_ep_struct *imx_ep,
 337                                                         struct imx_request *req)
 338 {
 339         if (unlikely(!req))
 340                 return;
 341
 342         req->in_use = 1;
 343         list_add_tail(&req->queue, &imx_ep->queue);
 344 }
 345
 346 static void ep_del_request(struct imx_ep_struct *imx_ep,
 347                                                         struct imx_request *req)
 348 {
 349         if (unlikely(!req))
 350                 return;
 351
 352         list_del_init(&req->queue);
 353         req->in_use = 0;
 354 }
 355
 356 static void done(struct imx_ep_struct *imx_ep,
 357                                         struct imx_request *req, int status)
 358 {
 359         ep_del_request(imx_ep, req);
 360
 361         if (likely(req->req.status == -EINPROGRESS))
 362                 req->req.status = status;
 363         else
 364                 status = req->req.status;
 365
 366         if (status && status != -ESHUTDOWN)
 367                 D_ERR(imx_ep->imx_usb->dev,
 368                         "<%s> complete %s req %p stat %d len %u/%u\n", __func__,
 369                         imx_ep->ep.name, &req->req, status,
 370                         req->req.actual, req->req.length);
 371
 372         req->req.complete(&imx_ep->ep, &req->req);
 373 }
 374
 375 static void nuke(struct imx_ep_struct *imx_ep, int status)
 376 {
 377         struct imx_request *req;
 378
 379         while (!list_empty(&imx_ep->queue)) {
 380                 req = list_entry(imx_ep->queue.next, struct imx_request, queue);
 381                 done(imx_ep, req, status);
 382         }
 383 }
 384
 385 /*******************************************************************************
 386  * Data tansfer over USB functions
 387  *******************************************************************************
 388  */
 389 static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
 390 {
 391         u8      *buf;
 392         int     bytes_ep, bufferspace, count, i;
 393
 394         bytes_ep = imx_fifo_bcount(imx_ep);
 395         bufferspace = req->req.length - req->req.actual;
 396
 397         buf = req->req.buf + req->req.actual;
 398         prefetchw(buf);
 399
 400         if (unlikely(imx_ep_empty(imx_ep)))
 401                 count = 0;      /* zlp */
 402         else
 403                 count = min(bytes_ep, bufferspace);
 404
 405         for (i = count; i > 0; i--)
 406                 *buf++ = __raw_readb(imx_ep->imx_usb->base
 407                                                 + USB_EP_FDAT0(EP_NO(imx_ep)));
 408         req->req.actual += count;
 409
 410         return count;
 411 }
 412
 413 static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
 414 {
 415         u8      *buf;
 416         int     length, count, temp;
 417
 418         buf = req->req.buf + req->req.actual;
 419         prefetch(buf);
 420
 421         length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
 422
 423         if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
 424                 D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
 425                         __func__, imx_ep->ep.name);
 426                 return -1;
 427         }
 428
 429         req->req.actual += length;
 430         count = length;
 431
 432         if (!count && req->req.zero) {  /* zlp */
 433                 temp = __raw_readl(imx_ep->imx_usb->base
 434                         + USB_EP_STAT(EP_NO(imx_ep)));
 435                 __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
 436                         + USB_EP_STAT(EP_NO(imx_ep)));
 437                 D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
 438                 return 0;
 439         }
 440
 441         while (count--) {
 442                 if (count == 0) {       /* last byte */
 443                         temp = __raw_readl(imx_ep->imx_usb->base
 444                                 + USB_EP_FCTRL(EP_NO(imx_ep)));
 445                         __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
 446                                 + USB_EP_FCTRL(EP_NO(imx_ep)));
 447                 }
 448                 __raw_writeb(*buf++,
 449                         imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
 450         }
 451
 452         return length;
 453 }
 454
 455 static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
 456 {
 457         int     bytes = 0,
 458                 count,
 459                 completed = 0;
 460
 461         while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
 462                 & FSTAT_FR) {
 463                         count = read_packet(imx_ep, req);
 464                         bytes += count;
 465
 466                         completed = (count != imx_ep->fifosize);
 467                         if (completed || req->req.actual == req->req.length) {
 468                                 completed = 1;
 469                                 break;
 470                         }
 471         }
 472
 473         if (completed || !req->req.length) {
 474                 done(imx_ep, req, 0);
 475                 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
 476                         __func__, imx_ep->ep.name, req,
 477                         completed ? "completed" : "not completed");
 478                 if (!EP_NO(imx_ep))
 479                         ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
 480         }
 481
 482         D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
 483
 484         return completed;
 485 }
 486
 487 static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
 488 {
 489         int     bytes = 0,
 490                 count,
 491                 completed = 0;
 492
 493         while (!completed) {
 494                 count = write_packet(imx_ep, req);
 495                 if (count < 0)
 496                         break; /* busy */
 497                 bytes += count;
 498
 499                 /* last packet "must be" short (or a zlp) */
 500                 completed = (count != imx_ep->fifosize);
 501
 502                 if (unlikely(completed)) {
 503                         done(imx_ep, req, 0);
 504                         D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
 505                                 __func__, imx_ep->ep.name, req,
 506                                 completed ? "completed" : "not completed");
 507                         if (!EP_NO(imx_ep))
 508                                 ep0_chg_stat(__func__,
 509                                                 imx_ep->imx_usb, EP0_IDLE);
 510                 }
 511         }
 512
 513         D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
 514
 515         return completed;
 516 }
 517
 518 /*******************************************************************************
 519  * Endpoint handlers
 520  *******************************************************************************
 521  */
 522 static int handle_ep(struct imx_ep_struct *imx_ep)
 523 {
 524         struct imx_request *req;
 525         int completed = 0;
 526
 527         do {
 528                 if (!list_empty(&imx_ep->queue))
 529                         req = list_entry(imx_ep->queue.next,
 530                                 struct imx_request, queue);
 531                 else {
 532                         D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
 533                                 __func__, imx_ep->ep.name);
 534                         return 0;
 535                 }
 536
 537                 if (EP_DIR(imx_ep))     /* to host */
 538                         completed = write_fifo(imx_ep, req);
 539                 else                    /* to device */
 540                         completed = read_fifo(imx_ep, req);
 541
 542                 dump_ep_stat(__func__, imx_ep);
 543
 544         } while (completed);
 545
 546         return 0;
 547 }
 548
 549 static int handle_ep0(struct imx_ep_struct *imx_ep)
 550 {
 551         struct imx_request *req = NULL;
 552         int ret = 0;
 553
 554         if (!list_empty(&imx_ep->queue)) {
 555                 req = list_entry(imx_ep->queue.next, struct imx_request, queue);
 556
 557                 switch (imx_ep->imx_usb->ep0state) {
 558
 559                 case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR */
 560                         write_fifo(imx_ep, req);
 561                         break;
 562                 case EP0_OUT_DATA_PHASE:                /* SET_DESCRIPTOR */
 563                         read_fifo(imx_ep, req);
 564                         break;
 565                 default:
 566                         D_EP0(imx_ep->imx_usb->dev,
 567                                 "<%s> ep0 i/o, odd state %d\n",
 568                                 __func__, imx_ep->imx_usb->ep0state);
 569                         ep_del_request(imx_ep, req);
 570                         ret = -EL2HLT;
 571                         break;
 572                 }
 573         }
 574
 575         else
 576                 D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
 577                                                 __func__, imx_ep->ep.name);
 578
 579         return ret;
 580 }
 581
 582 static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
 583 {
 584         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
 585         union {
 586                 struct usb_ctrlrequest  r;
 587                 u8                      raw[8];
 588                 u32                     word[2];
 589         } u;
 590         int temp, i;
 591
 592         nuke(imx_ep, -EPROTO);
 593
 594         /* read SETUP packet */
 595         for (i = 0; i < 2; i++) {
 596                 if (imx_ep_empty(imx_ep)) {
 597                         D_ERR(imx_usb->dev,
 598                                 "<%s> no setup packet received\n", __func__);
 599                         goto stall;
 600                 }
 601                 u.word[i] = __raw_readl(imx_usb->base
 602                                                 + USB_EP_FDAT(EP_NO(imx_ep)));
 603         }
 604
 605         temp = imx_ep_empty(imx_ep);
 606         while (!imx_ep_empty(imx_ep)) {
 607                 i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
 608                 D_ERR(imx_usb->dev,
 609                         "<%s> wrong to have extra bytes for setup : 0x%08x\n",
 610                         __func__, i);
 611         }
 612         if (!temp)
 613                 goto stall;
 614
 615         le16_to_cpus(&u.r.wValue);
 616         le16_to_cpus(&u.r.wIndex);
 617         le16_to_cpus(&u.r.wLength);
 618
 619         D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
 620                 __func__, u.r.bRequestType, u.r.bRequest,
 621                 u.r.wValue, u.r.wIndex, u.r.wLength);
 622
 623         if (imx_usb->set_config) {
 624                 /* NACK the host by using CMDOVER */
 625                 temp = __raw_readl(imx_usb->base + USB_CTRL);
 626                 __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
 627
 628                 D_ERR(imx_usb->dev,
 629                         "<%s> set config req is pending, NACK the host\n",
 630                         __func__);
 631                 return;
 632         }
 633
 634         if (u.r.bRequestType & USB_DIR_IN)
 635                 ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
 636         else
 637                 ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
 638
 639         i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
 640         if (i < 0) {
 641                 D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
 642                         __func__, i);
 643                 goto stall;
 644         }
 645
 646         return;
 647 stall:
 648         D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
 649         imx_ep_stall(imx_ep);
 650         ep0_chg_stat(__func__, imx_usb, EP0_STALL);
 651         return;
 652 }
 653
 654 /*******************************************************************************
 655  * USB gadget callback functions
 656  *******************************************************************************
 657  */
 658
 659 static int imx_ep_enable(struct usb_ep *usb_ep,
 660                                 const struct usb_endpoint_descriptor *desc)
 661 {
 662         struct imx_ep_struct *imx_ep = container_of(usb_ep,
 663                                                 struct imx_ep_struct, ep);
 664         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 665         unsigned long flags;
 666
 667         if (!usb_ep
 668                 || !desc
 669                 || !EP_NO(imx_ep)
 670                 || desc->bDescriptorType != USB_DT_ENDPOINT
 671                 || imx_ep->bEndpointAddress != desc->bEndpointAddress) {
 672                         D_ERR(imx_usb->dev,
 673                                 "<%s> bad ep or descriptor\n", __func__);
 674                         return -EINVAL;
 675         }
 676
 677         if (imx_ep->bmAttributes != desc->bmAttributes) {
 678                 D_ERR(imx_usb->dev,
 679                         "<%s> %s type mismatch\n", __func__, usb_ep->name);
 680                 return -EINVAL;
 681         }
 682
 683         if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
 684                 D_ERR(imx_usb->dev,
 685                         "<%s> bad %s maxpacket\n", __func__, usb_ep->name);
 686                 return -ERANGE;
 687         }
 688
 689         if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
 690                 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
 691                 return -ESHUTDOWN;
 692         }
 693
 694         local_irq_save(flags);
 695
 696         imx_ep->stopped = 0;
 697         imx_flush(imx_ep);
 698         imx_ep_irq_enable(imx_ep);
 699
 700         local_irq_restore(flags);
 701
 702         D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
 703         return 0;
 704 }
 705
 706 static int imx_ep_disable(struct usb_ep *usb_ep)
 707 {
 708         struct imx_ep_struct *imx_ep = container_of(usb_ep,
 709                                                 struct imx_ep_struct, ep);
 710         unsigned long flags;
 711
 712         if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
 713                 D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
 714                         __func__, usb_ep ? imx_ep->ep.name : NULL);
 715                 return -EINVAL;
 716         }
 717
 718         local_irq_save(flags);
 719
 720         imx_ep->stopped = 1;
 721         nuke(imx_ep, -ESHUTDOWN);
 722         imx_flush(imx_ep);
 723         imx_ep_irq_disable(imx_ep);
 724
 725         local_irq_restore(flags);
 726
 727         D_EPX(imx_ep->imx_usb->dev,
 728                 "<%s> DISABLED %s\n", __func__, usb_ep->name);
 729         return 0;
 730 }
 731
 732 static struct usb_request *imx_ep_alloc_request
 733                                         (struct usb_ep *usb_ep, gfp_t gfp_flags)
 734 {
 735         struct imx_request *req;
 736
 737         req = kzalloc(sizeof *req, gfp_flags);
 738         if (!req || !usb_ep)
 739                 return 0;
 740
 741         INIT_LIST_HEAD(&req->queue);
 742         req->in_use = 0;
 743
 744         return &req->req;
 745 }
 746
 747 static void imx_ep_free_request
 748                         (struct usb_ep *usb_ep, struct usb_request *usb_req)
 749 {
 750         struct imx_request *req;
 751
 752         req = container_of(usb_req, struct imx_request, req);
 753         WARN_ON(!list_empty(&req->queue));
 754         kfree(req);
 755 }
 756
 757 static int imx_ep_queue
 758         (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
 759 {
 760         struct imx_ep_struct    *imx_ep;
 761         struct imx_udc_struct   *imx_usb;
 762         struct imx_request      *req;
 763         unsigned long           flags;
 764         int                     ret = 0;
 765
 766         imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
 767         imx_usb = imx_ep->imx_usb;
 768         req = container_of(usb_req, struct imx_request, req);
 769
 770         /*
 771           Special care on IMX udc.
 772           Ignore enqueue when after set configuration from the
 773           host. This assume all gadget drivers reply set
 774           configuration with the next ep0 req enqueue.
 775         */
 776         if (imx_usb->set_config && !EP_NO(imx_ep)) {
 777                 imx_usb->set_config = 0;
 778                 D_ERR(imx_usb->dev,
 779                         "<%s> gadget reply set config\n", __func__);
 780                 return 0;
 781         }
 782
 783         if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
 784                 D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
 785                 return -EINVAL;
 786         }
 787
 788         if (unlikely(!usb_ep || !imx_ep)) {
 789                 D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
 790                 return -EINVAL;
 791         }
 792
 793         if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
 794                 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
 795                 return -ESHUTDOWN;
 796         }
 797
 798         /* Debug */
 799         D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
 800                 __func__, EP_NO(imx_ep),
 801                 ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
 802                                                         == EP0_IN_DATA_PHASE)
 803                 || (EP_NO(imx_ep) && EP_DIR(imx_ep)))
 804                                         ? "IN" : "OUT", usb_req->length);
 805         dump_req(__func__, imx_ep, usb_req);
 806
 807         if (imx_ep->stopped) {
 808                 usb_req->status = -ESHUTDOWN;
 809                 return -ESHUTDOWN;
 810         }
 811
 812         if (req->in_use) {
 813                 D_ERR(imx_usb->dev,
 814                         "<%s> refusing to queue req %p (already queued)\n",
 815                         __func__, req);
 816                 return 0;
 817         }
 818
 819         local_irq_save(flags);
 820
 821         usb_req->status = -EINPROGRESS;
 822         usb_req->actual = 0;
 823
 824         ep_add_request(imx_ep, req);
 825
 826         if (!EP_NO(imx_ep))
 827                 ret = handle_ep0(imx_ep);
 828         else
 829                 ret = handle_ep(imx_ep);
 830
 831         local_irq_restore(flags);
 832         return ret;
 833 }
 834
 835 static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
 836 {
 837
 838         struct imx_ep_struct *imx_ep = container_of
 839                                         (usb_ep, struct imx_ep_struct, ep);
 840         struct imx_request *req;
 841         unsigned long flags;
 842
 843         if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
 844                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 845                 return -EINVAL;
 846         }
 847
 848         local_irq_save(flags);
 849
 850         /* make sure it's actually queued on this endpoint */
 851         list_for_each_entry(req, &imx_ep->queue, queue) {
 852                 if (&req->req == usb_req)
 853                         break;
 854         }
 855         if (&req->req != usb_req) {
 856                 local_irq_restore(flags);
 857                 return -EINVAL;
 858         }
 859
 860         done(imx_ep, req, -ECONNRESET);
 861
 862         local_irq_restore(flags);
 863         return 0;
 864 }
 865
 866 static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
 867 {
 868         struct imx_ep_struct *imx_ep = container_of
 869                                         (usb_ep, struct imx_ep_struct, ep);
 870         unsigned long flags;
 871
 872         if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
 873                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 874                 return -EINVAL;
 875         }
 876
 877         local_irq_save(flags);
 878
 879         if ((imx_ep->bEndpointAddress & USB_DIR_IN)
 880                 && !list_empty(&imx_ep->queue)) {
 881                         local_irq_restore(flags);
 882                         return -EAGAIN;
 883         }
 884
 885         imx_ep_stall(imx_ep);
 886
 887         local_irq_restore(flags);
 888
 889         D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
 890         return 0;
 891 }
 892
 893 static int imx_ep_fifo_status(struct usb_ep *usb_ep)
 894 {
 895         struct imx_ep_struct *imx_ep = container_of
 896                                         (usb_ep, struct imx_ep_struct, ep);
 897
 898         if (!usb_ep) {
 899                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 900                 return -ENODEV;
 901         }
 902
 903         if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
 904                 return 0;
 905         else
 906                 return imx_fifo_bcount(imx_ep);
 907 }
 908
 909 static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
 910 {
 911         struct imx_ep_struct *imx_ep = container_of
 912                                         (usb_ep, struct imx_ep_struct, ep);
 913         unsigned long flags;
 914
 915         local_irq_save(flags);
 916
 917         if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
 918                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 919                 local_irq_restore(flags);
 920                 return;
 921         }
 922
 923         /* toggle and halt bits stay unchanged */
 924         imx_flush(imx_ep);
 925
 926         local_irq_restore(flags);
 927 }
 928
 929 static struct usb_ep_ops imx_ep_ops = {
 930         .enable         = imx_ep_enable,
 931         .disable        = imx_ep_disable,
 932
 933         .alloc_request  = imx_ep_alloc_request,
 934         .free_request   = imx_ep_free_request,
 935
 936         .queue          = imx_ep_queue,
 937         .dequeue        = imx_ep_dequeue,
 938
 939         .set_halt       = imx_ep_set_halt,
 940         .fifo_status    = imx_ep_fifo_status,
 941         .fifo_flush     = imx_ep_fifo_flush,
 942 };
 943
 944 /*******************************************************************************
 945  * USB endpoint control functions
 946  *******************************************************************************
 947  */
 948
 949 void ep0_chg_stat(const char *label,
 950                         struct imx_udc_struct *imx_usb, enum ep0_state stat)
 951 {
 952         D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
 953                 label, state_name[imx_usb->ep0state], state_name[stat]);
 954
 955         if (imx_usb->ep0state == stat)
 956                 return;
 957
 958         imx_usb->ep0state = stat;
 959 }
 960
 961 static void usb_init_data(struct imx_udc_struct *imx_usb)
 962 {
 963         struct imx_ep_struct *imx_ep;
 964         u8 i;
 965
 966         /* device/ep0 records init */
 967         INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
 968         INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
 969         ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
 970
 971         /* basic endpoint records init */
 972         for (i = 0; i < IMX_USB_NB_EP; i++) {
 973                 imx_ep = &imx_usb->imx_ep[i];
 974
 975                 if (i) {
 976                         list_add_tail(&imx_ep->ep.ep_list,
 977                                 &imx_usb->gadget.ep_list);
 978                         imx_ep->stopped = 1;
 979                 } else
 980                         imx_ep->stopped = 0;
 981
 982                 INIT_LIST_HEAD(&imx_ep->queue);
 983         }
 984 }
 985
 986 static void udc_stop_activity(struct imx_udc_struct *imx_usb,
 987                                         struct usb_gadget_driver *driver)
 988 {
 989         struct imx_ep_struct *imx_ep;
 990         int i;
 991
 992         if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
 993                 driver = NULL;
 994
 995         /* prevent new request submissions, kill any outstanding requests  */
 996         for (i = 1; i < IMX_USB_NB_EP; i++) {
 997                 imx_ep = &imx_usb->imx_ep[i];
 998                 imx_flush(imx_ep);
 999                 imx_ep->stopped = 1;
1000                 imx_ep_irq_disable(imx_ep);
1001                 nuke(imx_ep, -ESHUTDOWN);
1002         }
1003
1004         imx_usb->cfg = 0;
1005         imx_usb->intf = 0;
1006         imx_usb->alt = 0;
1007
1008         if (driver)
1009                 driver->disconnect(&imx_usb->gadget);
1010 }
1011
1012 /*******************************************************************************
1013  * Interrupt handlers
1014  *******************************************************************************
1015  */
1016
1017 /*
1018  * Called when timer expires.
1019  * Timer is started when CFG_CHG is received.
1020  */
1021 static void handle_config(unsigned long data)
1022 {
1023         struct imx_udc_struct *imx_usb = (void *)data;
1024         struct usb_ctrlrequest u;
1025         int temp, cfg, intf, alt;
1026
1027         local_irq_disable();
1028
1029         temp = __raw_readl(imx_usb->base + USB_STAT);
1030         cfg  = (temp & STAT_CFG) >> 5;
1031         intf = (temp & STAT_INTF) >> 3;
1032         alt  =  temp & STAT_ALTSET;
1033
1034         D_REQ(imx_usb->dev,
1035                 "<%s> orig config C=%d, I=%d, A=%d / "
1036                 "req config C=%d, I=%d, A=%d\n",
1037                 __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
1038                 cfg, intf, alt);
1039
1040         if (cfg == 1 || cfg == 2) {
1041
1042                 if (imx_usb->cfg != cfg) {
1043                         u.bRequest = USB_REQ_SET_CONFIGURATION;
1044                         u.bRequestType = USB_DIR_OUT |
1045                                         USB_TYPE_STANDARD |
1046                                         USB_RECIP_DEVICE;
1047                         u.wValue = cfg;
1048                         u.wIndex = 0;
1049                         u.wLength = 0;
1050                         imx_usb->cfg = cfg;
1051                         imx_usb->driver->setup(&imx_usb->gadget, &u);
1052
1053                 }
1054                 if (imx_usb->intf != intf || imx_usb->alt != alt) {
1055                         u.bRequest = USB_REQ_SET_INTERFACE;
1056                         u.bRequestType = USB_DIR_OUT |
1057                                           USB_TYPE_STANDARD |
1058                                           USB_RECIP_INTERFACE;
1059                         u.wValue = alt;
1060                         u.wIndex = intf;
1061                         u.wLength = 0;
1062                         imx_usb->intf = intf;
1063                         imx_usb->alt = alt;
1064                         imx_usb->driver->setup(&imx_usb->gadget, &u);
1065                 }
1066         }
1067
1068         imx_usb->set_config = 0;
1069
1070         local_irq_enable();
1071 }
1072
1073 static irqreturn_t imx_udc_irq(int irq, void *dev)
1074 {
1075         struct imx_udc_struct *imx_usb = dev;
1076         int intr = __raw_readl(imx_usb->base + USB_INTR);
1077         int temp;
1078
1079         if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
1080                         | INTR_RESET_STOP | INTR_CFG_CHG)) {
1081                                 dump_intr(__func__, intr, imx_usb->dev);
1082                                 dump_usb_stat(__func__, imx_usb);
1083         }
1084
1085         if (!imx_usb->driver)
1086                 goto end_irq;
1087
1088         if (intr & INTR_SOF) {
1089                 /* Copy from Freescale BSP.
1090                    We must enable SOF intr and set CMDOVER.
1091                    Datasheet don't specifiy this action, but it
1092                    is done in Freescale BSP, so just copy it.
1093                 */
1094                 if (imx_usb->ep0state == EP0_IDLE) {
1095                         temp = __raw_readl(imx_usb->base + USB_CTRL);
1096                         __raw_writel(temp | CTRL_CMDOVER,
1097                                                 imx_usb->base + USB_CTRL);
1098                 }
1099         }
1100
1101         if (intr & INTR_CFG_CHG) {
1102                 /* A workaround of serious IMX UDC bug.
1103                    Handling of CFG_CHG should be delayed for some time, because
1104                    IMX does not NACK the host when CFG_CHG interrupt is pending.
1105                    There is no time to handle current CFG_CHG
1106                    if next CFG_CHG or SETUP packed is send immediately.
1107                    We have to clear CFG_CHG, start the timer and
1108                    NACK the host by setting CTRL_CMDOVER
1109                    if it sends any SETUP packet.
1110                    When timer expires, handler is called to handle configuration
1111                    changes. While CFG_CHG is not handled (set_config=1),
1112                    we must NACK the host to every SETUP packed.
1113                    This delay prevents from going out of sync with host.
1114                  */
1115                 __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
1116                 imx_usb->set_config = 1;
1117                 mod_timer(&imx_usb->timer, jiffies + 5);
1118                 goto end_irq;
1119         }
1120
1121         if (intr & INTR_WAKEUP) {
1122                 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
1123                         && imx_usb->driver && imx_usb->driver->resume)
1124                                 imx_usb->driver->resume(&imx_usb->gadget);
1125                 imx_usb->set_config = 0;
1126                 del_timer(&imx_usb->timer);
1127                 imx_usb->gadget.speed = USB_SPEED_FULL;
1128         }
1129
1130         if (intr & INTR_SUSPEND) {
1131                 if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
1132                         && imx_usb->driver && imx_usb->driver->suspend)
1133                                 imx_usb->driver->suspend(&imx_usb->gadget);
1134                 imx_usb->set_config = 0;
1135                 del_timer(&imx_usb->timer);
1136                 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1137         }
1138
1139         if (intr & INTR_RESET_START) {
1140                 __raw_writel(intr, imx_usb->base + USB_INTR);
1141                 udc_stop_activity(imx_usb, imx_usb->driver);
1142                 imx_usb->set_config = 0;
1143                 del_timer(&imx_usb->timer);
1144                 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1145         }
1146
1147         if (intr & INTR_RESET_STOP)
1148                 imx_usb->gadget.speed = USB_SPEED_FULL;
1149
1150 end_irq:
1151         __raw_writel(intr, imx_usb->base + USB_INTR);
1152         return IRQ_HANDLED;
1153 }
1154
1155 static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
1156 {
1157         struct imx_udc_struct *imx_usb = dev;
1158         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
1159         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
1160
1161         dump_ep_intr(__func__, 0, intr, imx_usb->dev);
1162
1163         if (!imx_usb->driver) {
1164                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1165                 return IRQ_HANDLED;
1166         }
1167
1168         /* DEVREQ has highest priority */
1169         if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
1170                 handle_ep0_devreq(imx_usb);
1171         /* Seem i.MX is missing EOF interrupt sometimes.
1172          * Therefore we don't monitor EOF.
1173          * We call handle_ep0() only if a request is queued for ep0.
1174          */
1175         else if (!list_empty(&imx_ep->queue))
1176                 handle_ep0(imx_ep);
1177
1178         __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1179
1180         return IRQ_HANDLED;
1181 }
1182
1183 static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
1184 {
1185         struct imx_udc_struct *imx_usb = dev;
1186         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
1187         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1188
1189         dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
1190
1191         if (!imx_usb->driver) {
1192                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1193                 return IRQ_HANDLED;
1194         }
1195
1196         handle_ep(imx_ep);
1197
1198         __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1199
1200         return IRQ_HANDLED;
1201 }
1202
1203 irq_handler_t intr_handler(int i)
1204 {
1205         switch (i) {
1206         case 0:
1207                 return imx_udc_ctrl_irq;
1208         case 1:
1209         case 2:
1210         case 3:
1211         case 4:
1212         case 5:
1213                 return imx_udc_bulk_irq;
1214         default:
1215                 return imx_udc_irq;
1216         }
1217 }
1218
1219 /*******************************************************************************
1220  * Static defined IMX UDC structure
1221  *******************************************************************************
1222  */
1223
1224 static const struct usb_gadget_ops imx_udc_ops = {
1225         .get_frame       = imx_udc_get_frame,
1226         .wakeup          = imx_udc_wakeup,
1227 };
1228
1229 static struct imx_udc_struct controller = {
1230         .gadget = {
1231                 .ops            = &imx_udc_ops,
1232                 .ep0            = &controller.imx_ep[0].ep,
1233                 .name           = driver_name,
1234                 .dev = {
1235                         .init_name      = "gadget",
1236                 },
1237         },
1238
1239         .imx_ep[0] = {
1240                 .ep = {
1241                         .name           = ep0name,
1242                         .ops            = &imx_ep_ops,
1243                         .maxpacket      = 32,
1244                 },
1245                 .imx_usb                = &controller,
1246                 .fifosize               = 32,
1247                 .bEndpointAddress       = 0,
1248                 .bmAttributes           = USB_ENDPOINT_XFER_CONTROL,
1249          },
1250         .imx_ep[1] = {
1251                 .ep = {
1252                         .name           = "ep1in-bulk",
1253                         .ops            = &imx_ep_ops,
1254                         .maxpacket      = 64,
1255                 },
1256                 .imx_usb                = &controller,
1257                 .fifosize               = 64,
1258                 .bEndpointAddress       = USB_DIR_IN | 1,
1259                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1260          },
1261         .imx_ep[2] = {
1262                 .ep = {
1263                         .name           = "ep2out-bulk",
1264                         .ops            = &imx_ep_ops,
1265                         .maxpacket      = 64,
1266                 },
1267                 .imx_usb                = &controller,
1268                 .fifosize               = 64,
1269                 .bEndpointAddress       = USB_DIR_OUT | 2,
1270                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1271          },
1272         .imx_ep[3] = {
1273                 .ep = {
1274                         .name           = "ep3out-bulk",
1275                         .ops            = &imx_ep_ops,
1276                         .maxpacket      = 32,
1277                 },
1278                 .imx_usb                = &controller,
1279                 .fifosize               = 32,
1280                 .bEndpointAddress       = USB_DIR_OUT | 3,
1281                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1282          },
1283         .imx_ep[4] = {
1284                 .ep = {
1285                         .name           = "ep4in-int",
1286                         .ops            = &imx_ep_ops,
1287                         .maxpacket      = 32,
1288                  },
1289                 .imx_usb                = &controller,
1290                 .fifosize               = 32,
1291                 .bEndpointAddress       = USB_DIR_IN | 4,
1292                 .bmAttributes           = USB_ENDPOINT_XFER_INT,
1293          },
1294         .imx_ep[5] = {
1295                 .ep = {
1296                         .name           = "ep5out-int",
1297                         .ops            = &imx_ep_ops,
1298                         .maxpacket      = 32,
1299                 },
1300                 .imx_usb                = &controller,
1301                 .fifosize               = 32,
1302                 .bEndpointAddress       = USB_DIR_OUT | 5,
1303                 .bmAttributes           = USB_ENDPOINT_XFER_INT,
1304          },
1305 };
1306
1307 /*******************************************************************************
1308  * USB gadged driver functions
1309  *******************************************************************************
1310  */
1311 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1312 {
1313         struct imx_udc_struct *imx_usb = &controller;
1314         int retval;
1315
1316         if (!driver
1317                 || driver->speed < USB_SPEED_FULL
1318                 || !driver->bind
1319                 || !driver->disconnect
1320                 || !driver->setup)
1321                         return -EINVAL;
1322         if (!imx_usb)
1323                 return -ENODEV;
1324         if (imx_usb->driver)
1325                 return -EBUSY;
1326
1327         /* first hook up the driver ... */
1328         imx_usb->driver = driver;
1329         imx_usb->gadget.dev.driver = &driver->driver;
1330
1331         retval = device_add(&imx_usb->gadget.dev);
1332         if (retval)
1333                 goto fail;
1334         retval = driver->bind(&imx_usb->gadget);
1335         if (retval) {
1336                 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
1337                         __func__, driver->driver.name, retval);
1338                 device_del(&imx_usb->gadget.dev);
1339
1340                 goto fail;
1341         }
1342
1343         D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
1344                 __func__, driver->driver.name);
1345
1346         imx_udc_enable(imx_usb);
1347
1348         return 0;
1349 fail:
1350         imx_usb->driver = NULL;
1351         imx_usb->gadget.dev.driver = NULL;
1352         return retval;
1353 }
1354 EXPORT_SYMBOL(usb_gadget_register_driver);
1355
1356 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1357 {
1358         struct imx_udc_struct *imx_usb = &controller;
1359
1360         if (!imx_usb)
1361                 return -ENODEV;
1362         if (!driver || driver != imx_usb->driver || !driver->unbind)
1363                 return -EINVAL;
1364
1365         udc_stop_activity(imx_usb, driver);
1366         imx_udc_disable(imx_usb);
1367         del_timer(&imx_usb->timer);
1368
1369         driver->unbind(&imx_usb->gadget);
1370         imx_usb->gadget.dev.driver = NULL;
1371         imx_usb->driver = NULL;
1372
1373         device_del(&imx_usb->gadget.dev);
1374
1375         D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
1376                 __func__, driver->driver.name);
1377
1378         return 0;
1379 }
1380 EXPORT_SYMBOL(usb_gadget_unregister_driver);
1381
1382 /*******************************************************************************
1383  * Module functions
1384  *******************************************************************************
1385  */
1386
1387 static int __init imx_udc_probe(struct platform_device *pdev)
1388 {
1389         struct imx_udc_struct *imx_usb = &controller;
1390         struct resource *res;
1391         struct imxusb_platform_data *pdata;
1392         struct clk *clk;
1393         void __iomem *base;
1394         int ret = 0;
1395         int i, res_size;
1396
1397         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1398         if (!res) {
1399                 dev_err(&pdev->dev, "can't get device resources\n");
1400                 return -ENODEV;
1401         }
1402
1403         pdata = pdev->dev.platform_data;
1404         if (!pdata) {
1405                 dev_err(&pdev->dev, "driver needs platform data\n");
1406                 return -ENODEV;
1407         }
1408
1409         res_size = res->end - res->start + 1;
1410         if (!request_mem_region(res->start, res_size, res->name)) {
1411                 dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
1412                         res_size, res->start);
1413                 return -ENOMEM;
1414         }
1415
1416         if (pdata->init) {
1417                 ret = pdata->init(&pdev->dev);
1418                 if (ret)
1419                         goto fail0;
1420         }
1421
1422         base = ioremap(res->start, res_size);
1423         if (!base) {
1424                 dev_err(&pdev->dev, "ioremap failed\n");
1425                 ret = -EIO;
1426                 goto fail1;
1427         }
1428
1429         clk = clk_get(NULL, "usbd_clk");
1430         if (IS_ERR(clk)) {
1431                 ret = PTR_ERR(clk);
1432                 dev_err(&pdev->dev, "can't get USB clock\n");
1433                 goto fail2;
1434         }
1435         clk_enable(clk);
1436
1437         if (clk_get_rate(clk) != 48000000) {
1438                 D_INI(&pdev->dev,
1439                         "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
1440                         (int)clk_get_rate(clk));
1441                 if (clk_set_rate(clk, 48000000)) {
1442                         dev_err(&pdev->dev,
1443                                 "Unable to set correct USB clock (48MHz)\n");
1444                         ret = -EIO;
1445                         goto fail3;
1446                 }
1447         }
1448
1449         for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1450                 imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
1451                 if (imx_usb->usbd_int[i] < 0) {
1452                         dev_err(&pdev->dev, "can't get irq number\n");
1453                         ret = -ENODEV;
1454                         goto fail3;
1455                 }
1456         }
1457
1458         for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1459                 ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
1460                                      IRQF_DISABLED, driver_name, imx_usb);
1461                 if (ret) {
1462                         dev_err(&pdev->dev, "can't get irq %i, err %d\n",
1463                                 imx_usb->usbd_int[i], ret);
1464                         for (--i; i >= 0; i--)
1465                                 free_irq(imx_usb->usbd_int[i], imx_usb);
1466                         goto fail3;
1467                 }
1468         }
1469
1470         imx_usb->res = res;
1471         imx_usb->base = base;
1472         imx_usb->clk = clk;
1473         imx_usb->dev = &pdev->dev;
1474
1475         device_initialize(&imx_usb->gadget.dev);
1476
1477         imx_usb->gadget.dev.parent = &pdev->dev;
1478         imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
1479
1480         platform_set_drvdata(pdev, imx_usb);
1481
1482         usb_init_data(imx_usb);
1483         imx_udc_init(imx_usb);
1484
1485         init_timer(&imx_usb->timer);
1486         imx_usb->timer.function = handle_config;
1487         imx_usb->timer.data = (unsigned long)imx_usb;
1488
1489         return 0;
1490
1491 fail3:
1492         clk_put(clk);
1493         clk_disable(clk);
1494 fail2:
1495         iounmap(base);
1496 fail1:
1497         if (pdata->exit)
1498                 pdata->exit(&pdev->dev);
1499 fail0:
1500         release_mem_region(res->start, res_size);
1501         return ret;
1502 }
1503
1504 static int __exit imx_udc_remove(struct platform_device *pdev)
1505 {
1506         struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
1507         struct imxusb_platform_data *pdata = pdev->dev.platform_data;
1508         int i;
1509
1510         imx_udc_disable(imx_usb);
1511         del_timer(&imx_usb->timer);
1512
1513         for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1514                 free_irq(imx_usb->usbd_int[i], imx_usb);
1515
1516         clk_put(imx_usb->clk);
1517         clk_disable(imx_usb->clk);
1518         iounmap(imx_usb->base);
1519
1520         release_mem_region(imx_usb->res->start,
1521                 imx_usb->res->end - imx_usb->res->start + 1);
1522
1523         if (pdata->exit)
1524                 pdata->exit(&pdev->dev);
1525
1526         platform_set_drvdata(pdev, NULL);
1527
1528         return 0;
1529 }
1530
1531 /*----------------------------------------------------------------------------*/
1532
1533 #ifdef  CONFIG_PM
1534 #define imx_udc_suspend NULL
1535 #define imx_udc_resume  NULL
1536 #else
1537 #define imx_udc_suspend NULL
1538 #define imx_udc_resume  NULL
1539 #endif
1540
1541 /*----------------------------------------------------------------------------*/
1542
1543 static struct platform_driver udc_driver = {
1544         .driver         = {
1545                 .name   = driver_name,
1546                 .owner  = THIS_MODULE,
1547         },
1548         .remove         = __exit_p(imx_udc_remove),
1549         .suspend        = imx_udc_suspend,
1550         .resume         = imx_udc_resume,
1551 };
1552
1553 static int __init udc_init(void)
1554 {
1555         return platform_driver_probe(&udc_driver, imx_udc_probe);
1556 }
1557 module_init(udc_init);
1558
1559 static void __exit udc_exit(void)
1560 {
1561         platform_driver_unregister(&udc_driver);
1562 }
1563 module_exit(udc_exit);
1564
1565 MODULE_DESCRIPTION("IMX USB Device Controller driver");
1566 MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
1567 MODULE_LICENSE("GPL");
1568 MODULE_ALIAS("platform:imx_udc");