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         if (unlikely(__raw_readl(imx_ep->imx_usb->base +
 419                                  USB_EP_STAT(EP_NO(imx_ep))) & EPSTAT_ZLPS)) {
 420                 D_TRX(imx_ep->imx_usb->dev, "<%s> zlp still queued in EP %s\n",
 421                         __func__, imx_ep->ep.name);
 422                 return -1;
 423         }
 424
 425         buf = req->req.buf + req->req.actual;
 426         prefetch(buf);
 427
 428         length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
 429
 430         if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
 431                 D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
 432                         __func__, imx_ep->ep.name);
 433                 return -1;
 434         }
 435
 436         req->req.actual += length;
 437         count = length;
 438
 439         if (!count && req->req.zero) {  /* zlp */
 440                 temp = __raw_readl(imx_ep->imx_usb->base
 441                         + USB_EP_STAT(EP_NO(imx_ep)));
 442                 __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
 443                         + USB_EP_STAT(EP_NO(imx_ep)));
 444                 D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
 445                 return 0;
 446         }
 447
 448         while (count--) {
 449                 if (count == 0) {       /* last byte */
 450                         temp = __raw_readl(imx_ep->imx_usb->base
 451                                 + USB_EP_FCTRL(EP_NO(imx_ep)));
 452                         __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
 453                                 + USB_EP_FCTRL(EP_NO(imx_ep)));
 454                 }
 455                 __raw_writeb(*buf++,
 456                         imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
 457         }
 458
 459         return length;
 460 }
 461
 462 static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
 463 {
 464         int     bytes = 0,
 465                 count,
 466                 completed = 0;
 467
 468         while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
 469                 & FSTAT_FR) {
 470                         count = read_packet(imx_ep, req);
 471                         bytes += count;
 472
 473                         completed = (count != imx_ep->fifosize);
 474                         if (completed || req->req.actual == req->req.length) {
 475                                 completed = 1;
 476                                 break;
 477                         }
 478         }
 479
 480         if (completed || !req->req.length) {
 481                 done(imx_ep, req, 0);
 482                 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
 483                         __func__, imx_ep->ep.name, req,
 484                         completed ? "completed" : "not completed");
 485                 if (!EP_NO(imx_ep))
 486                         ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
 487         }
 488
 489         D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
 490
 491         return completed;
 492 }
 493
 494 static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
 495 {
 496         int     bytes = 0,
 497                 count,
 498                 completed = 0;
 499
 500         while (!completed) {
 501                 count = write_packet(imx_ep, req);
 502                 if (count < 0)
 503                         break; /* busy */
 504                 bytes += count;
 505
 506                 /* last packet "must be" short (or a zlp) */
 507                 completed = (count != imx_ep->fifosize);
 508
 509                 if (unlikely(completed)) {
 510                         done(imx_ep, req, 0);
 511                         D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
 512                                 __func__, imx_ep->ep.name, req,
 513                                 completed ? "completed" : "not completed");
 514                         if (!EP_NO(imx_ep))
 515                                 ep0_chg_stat(__func__,
 516                                                 imx_ep->imx_usb, EP0_IDLE);
 517                 }
 518         }
 519
 520         D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
 521
 522         return completed;
 523 }
 524
 525 /*******************************************************************************
 526  * Endpoint handlers
 527  *******************************************************************************
 528  */
 529 static int handle_ep(struct imx_ep_struct *imx_ep)
 530 {
 531         struct imx_request *req;
 532         int completed = 0;
 533
 534         do {
 535                 if (!list_empty(&imx_ep->queue))
 536                         req = list_entry(imx_ep->queue.next,
 537                                 struct imx_request, queue);
 538                 else {
 539                         D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
 540                                 __func__, imx_ep->ep.name);
 541                         return 0;
 542                 }
 543
 544                 if (EP_DIR(imx_ep))     /* to host */
 545                         completed = write_fifo(imx_ep, req);
 546                 else                    /* to device */
 547                         completed = read_fifo(imx_ep, req);
 548
 549                 dump_ep_stat(__func__, imx_ep);
 550
 551         } while (completed);
 552
 553         return 0;
 554 }
 555
 556 static int handle_ep0(struct imx_ep_struct *imx_ep)
 557 {
 558         struct imx_request *req = NULL;
 559         int ret = 0;
 560
 561         if (!list_empty(&imx_ep->queue)) {
 562                 req = list_entry(imx_ep->queue.next, struct imx_request, queue);
 563
 564                 switch (imx_ep->imx_usb->ep0state) {
 565
 566                 case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR */
 567                         write_fifo(imx_ep, req);
 568                         break;
 569                 case EP0_OUT_DATA_PHASE:                /* SET_DESCRIPTOR */
 570                         read_fifo(imx_ep, req);
 571                         break;
 572                 default:
 573                         D_EP0(imx_ep->imx_usb->dev,
 574                                 "<%s> ep0 i/o, odd state %d\n",
 575                                 __func__, imx_ep->imx_usb->ep0state);
 576                         ep_del_request(imx_ep, req);
 577                         ret = -EL2HLT;
 578                         break;
 579                 }
 580         }
 581
 582         else
 583                 D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
 584                                                 __func__, imx_ep->ep.name);
 585
 586         return ret;
 587 }
 588
 589 static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
 590 {
 591         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
 592         union {
 593                 struct usb_ctrlrequest  r;
 594                 u8                      raw[8];
 595                 u32                     word[2];
 596         } u;
 597         int temp, i;
 598
 599         nuke(imx_ep, -EPROTO);
 600
 601         /* read SETUP packet */
 602         for (i = 0; i < 2; i++) {
 603                 if (imx_ep_empty(imx_ep)) {
 604                         D_ERR(imx_usb->dev,
 605                                 "<%s> no setup packet received\n", __func__);
 606                         goto stall;
 607                 }
 608                 u.word[i] = __raw_readl(imx_usb->base
 609                                                 + USB_EP_FDAT(EP_NO(imx_ep)));
 610         }
 611
 612         temp = imx_ep_empty(imx_ep);
 613         while (!imx_ep_empty(imx_ep)) {
 614                 i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
 615                 D_ERR(imx_usb->dev,
 616                         "<%s> wrong to have extra bytes for setup : 0x%08x\n",
 617                         __func__, i);
 618         }
 619         if (!temp)
 620                 goto stall;
 621
 622         le16_to_cpus(&u.r.wValue);
 623         le16_to_cpus(&u.r.wIndex);
 624         le16_to_cpus(&u.r.wLength);
 625
 626         D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
 627                 __func__, u.r.bRequestType, u.r.bRequest,
 628                 u.r.wValue, u.r.wIndex, u.r.wLength);
 629
 630         if (imx_usb->set_config) {
 631                 /* NACK the host by using CMDOVER */
 632                 temp = __raw_readl(imx_usb->base + USB_CTRL);
 633                 __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
 634
 635                 D_ERR(imx_usb->dev,
 636                         "<%s> set config req is pending, NACK the host\n",
 637                         __func__);
 638                 return;
 639         }
 640
 641         if (u.r.bRequestType & USB_DIR_IN)
 642                 ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
 643         else
 644                 ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
 645
 646         i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
 647         if (i < 0) {
 648                 D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
 649                         __func__, i);
 650                 goto stall;
 651         }
 652
 653         return;
 654 stall:
 655         D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
 656         imx_ep_stall(imx_ep);
 657         ep0_chg_stat(__func__, imx_usb, EP0_STALL);
 658         return;
 659 }
 660
 661 /*******************************************************************************
 662  * USB gadget callback functions
 663  *******************************************************************************
 664  */
 665
 666 static int imx_ep_enable(struct usb_ep *usb_ep,
 667                                 const struct usb_endpoint_descriptor *desc)
 668 {
 669         struct imx_ep_struct *imx_ep = container_of(usb_ep,
 670                                                 struct imx_ep_struct, ep);
 671         struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
 672         unsigned long flags;
 673
 674         if (!usb_ep
 675                 || !desc
 676                 || !EP_NO(imx_ep)
 677                 || desc->bDescriptorType != USB_DT_ENDPOINT
 678                 || imx_ep->bEndpointAddress != desc->bEndpointAddress) {
 679                         D_ERR(imx_usb->dev,
 680                                 "<%s> bad ep or descriptor\n", __func__);
 681                         return -EINVAL;
 682         }
 683
 684         if (imx_ep->bmAttributes != desc->bmAttributes) {
 685                 D_ERR(imx_usb->dev,
 686                         "<%s> %s type mismatch\n", __func__, usb_ep->name);
 687                 return -EINVAL;
 688         }
 689
 690         if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
 691                 D_ERR(imx_usb->dev,
 692                         "<%s> bad %s maxpacket\n", __func__, usb_ep->name);
 693                 return -ERANGE;
 694         }
 695
 696         if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
 697                 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
 698                 return -ESHUTDOWN;
 699         }
 700
 701         local_irq_save(flags);
 702
 703         imx_ep->stopped = 0;
 704         imx_flush(imx_ep);
 705         imx_ep_irq_enable(imx_ep);
 706
 707         local_irq_restore(flags);
 708
 709         D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
 710         return 0;
 711 }
 712
 713 static int imx_ep_disable(struct usb_ep *usb_ep)
 714 {
 715         struct imx_ep_struct *imx_ep = container_of(usb_ep,
 716                                                 struct imx_ep_struct, ep);
 717         unsigned long flags;
 718
 719         if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
 720                 D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
 721                         __func__, usb_ep ? imx_ep->ep.name : NULL);
 722                 return -EINVAL;
 723         }
 724
 725         local_irq_save(flags);
 726
 727         imx_ep->stopped = 1;
 728         nuke(imx_ep, -ESHUTDOWN);
 729         imx_flush(imx_ep);
 730         imx_ep_irq_disable(imx_ep);
 731
 732         local_irq_restore(flags);
 733
 734         D_EPX(imx_ep->imx_usb->dev,
 735                 "<%s> DISABLED %s\n", __func__, usb_ep->name);
 736         return 0;
 737 }
 738
 739 static struct usb_request *imx_ep_alloc_request
 740                                         (struct usb_ep *usb_ep, gfp_t gfp_flags)
 741 {
 742         struct imx_request *req;
 743
 744         if (!usb_ep)
 745                 return NULL;
 746
 747         req = kzalloc(sizeof *req, gfp_flags);
 748         if (!req)
 749                 return NULL;
 750
 751         INIT_LIST_HEAD(&req->queue);
 752         req->in_use = 0;
 753
 754         return &req->req;
 755 }
 756
 757 static void imx_ep_free_request
 758                         (struct usb_ep *usb_ep, struct usb_request *usb_req)
 759 {
 760         struct imx_request *req;
 761
 762         req = container_of(usb_req, struct imx_request, req);
 763         WARN_ON(!list_empty(&req->queue));
 764         kfree(req);
 765 }
 766
 767 static int imx_ep_queue
 768         (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
 769 {
 770         struct imx_ep_struct    *imx_ep;
 771         struct imx_udc_struct   *imx_usb;
 772         struct imx_request      *req;
 773         unsigned long           flags;
 774         int                     ret = 0;
 775
 776         imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
 777         imx_usb = imx_ep->imx_usb;
 778         req = container_of(usb_req, struct imx_request, req);
 779
 780         /*
 781           Special care on IMX udc.
 782           Ignore enqueue when after set configuration from the
 783           host. This assume all gadget drivers reply set
 784           configuration with the next ep0 req enqueue.
 785         */
 786         if (imx_usb->set_config && !EP_NO(imx_ep)) {
 787                 imx_usb->set_config = 0;
 788                 D_ERR(imx_usb->dev,
 789                         "<%s> gadget reply set config\n", __func__);
 790                 return 0;
 791         }
 792
 793         if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
 794                 D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
 795                 return -EINVAL;
 796         }
 797
 798         if (unlikely(!usb_ep || !imx_ep)) {
 799                 D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
 800                 return -EINVAL;
 801         }
 802
 803         if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
 804                 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
 805                 return -ESHUTDOWN;
 806         }
 807
 808         /* Debug */
 809         D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
 810                 __func__, EP_NO(imx_ep),
 811                 ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
 812                                                         == EP0_IN_DATA_PHASE)
 813                 || (EP_NO(imx_ep) && EP_DIR(imx_ep)))
 814                                         ? "IN" : "OUT", usb_req->length);
 815         dump_req(__func__, imx_ep, usb_req);
 816
 817         if (imx_ep->stopped) {
 818                 usb_req->status = -ESHUTDOWN;
 819                 return -ESHUTDOWN;
 820         }
 821
 822         if (req->in_use) {
 823                 D_ERR(imx_usb->dev,
 824                         "<%s> refusing to queue req %p (already queued)\n",
 825                         __func__, req);
 826                 return 0;
 827         }
 828
 829         local_irq_save(flags);
 830
 831         usb_req->status = -EINPROGRESS;
 832         usb_req->actual = 0;
 833
 834         ep_add_request(imx_ep, req);
 835
 836         if (!EP_NO(imx_ep))
 837                 ret = handle_ep0(imx_ep);
 838         else
 839                 ret = handle_ep(imx_ep);
 840
 841         local_irq_restore(flags);
 842         return ret;
 843 }
 844
 845 static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
 846 {
 847
 848         struct imx_ep_struct *imx_ep = container_of
 849                                         (usb_ep, struct imx_ep_struct, ep);
 850         struct imx_request *req;
 851         unsigned long flags;
 852
 853         if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
 854                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 855                 return -EINVAL;
 856         }
 857
 858         local_irq_save(flags);
 859
 860         /* make sure it's actually queued on this endpoint */
 861         list_for_each_entry(req, &imx_ep->queue, queue) {
 862                 if (&req->req == usb_req)
 863                         break;
 864         }
 865         if (&req->req != usb_req) {
 866                 local_irq_restore(flags);
 867                 return -EINVAL;
 868         }
 869
 870         done(imx_ep, req, -ECONNRESET);
 871
 872         local_irq_restore(flags);
 873         return 0;
 874 }
 875
 876 static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
 877 {
 878         struct imx_ep_struct *imx_ep = container_of
 879                                         (usb_ep, struct imx_ep_struct, ep);
 880         unsigned long flags;
 881
 882         if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
 883                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 884                 return -EINVAL;
 885         }
 886
 887         local_irq_save(flags);
 888
 889         if ((imx_ep->bEndpointAddress & USB_DIR_IN)
 890                 && !list_empty(&imx_ep->queue)) {
 891                         local_irq_restore(flags);
 892                         return -EAGAIN;
 893         }
 894
 895         imx_ep_stall(imx_ep);
 896
 897         local_irq_restore(flags);
 898
 899         D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
 900         return 0;
 901 }
 902
 903 static int imx_ep_fifo_status(struct usb_ep *usb_ep)
 904 {
 905         struct imx_ep_struct *imx_ep = container_of
 906                                         (usb_ep, struct imx_ep_struct, ep);
 907
 908         if (!usb_ep) {
 909                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 910                 return -ENODEV;
 911         }
 912
 913         if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
 914                 return 0;
 915         else
 916                 return imx_fifo_bcount(imx_ep);
 917 }
 918
 919 static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
 920 {
 921         struct imx_ep_struct *imx_ep = container_of
 922                                         (usb_ep, struct imx_ep_struct, ep);
 923         unsigned long flags;
 924
 925         local_irq_save(flags);
 926
 927         if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
 928                 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
 929                 local_irq_restore(flags);
 930                 return;
 931         }
 932
 933         /* toggle and halt bits stay unchanged */
 934         imx_flush(imx_ep);
 935
 936         local_irq_restore(flags);
 937 }
 938
 939 static struct usb_ep_ops imx_ep_ops = {
 940         .enable         = imx_ep_enable,
 941         .disable        = imx_ep_disable,
 942
 943         .alloc_request  = imx_ep_alloc_request,
 944         .free_request   = imx_ep_free_request,
 945
 946         .queue          = imx_ep_queue,
 947         .dequeue        = imx_ep_dequeue,
 948
 949         .set_halt       = imx_ep_set_halt,
 950         .fifo_status    = imx_ep_fifo_status,
 951         .fifo_flush     = imx_ep_fifo_flush,
 952 };
 953
 954 /*******************************************************************************
 955  * USB endpoint control functions
 956  *******************************************************************************
 957  */
 958
 959 void ep0_chg_stat(const char *label,
 960                         struct imx_udc_struct *imx_usb, enum ep0_state stat)
 961 {
 962         D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
 963                 label, state_name[imx_usb->ep0state], state_name[stat]);
 964
 965         if (imx_usb->ep0state == stat)
 966                 return;
 967
 968         imx_usb->ep0state = stat;
 969 }
 970
 971 static void usb_init_data(struct imx_udc_struct *imx_usb)
 972 {
 973         struct imx_ep_struct *imx_ep;
 974         u8 i;
 975
 976         /* device/ep0 records init */
 977         INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
 978         INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
 979         ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
 980
 981         /* basic endpoint records init */
 982         for (i = 0; i < IMX_USB_NB_EP; i++) {
 983                 imx_ep = &imx_usb->imx_ep[i];
 984
 985                 if (i) {
 986                         list_add_tail(&imx_ep->ep.ep_list,
 987                                 &imx_usb->gadget.ep_list);
 988                         imx_ep->stopped = 1;
 989                 } else
 990                         imx_ep->stopped = 0;
 991
 992                 INIT_LIST_HEAD(&imx_ep->queue);
 993         }
 994 }
 995
 996 static void udc_stop_activity(struct imx_udc_struct *imx_usb,
 997                                         struct usb_gadget_driver *driver)
 998 {
 999         struct imx_ep_struct *imx_ep;
1000         int i;
1001
1002         if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
1003                 driver = NULL;
1004
1005         /* prevent new request submissions, kill any outstanding requests  */
1006         for (i = 1; i < IMX_USB_NB_EP; i++) {
1007                 imx_ep = &imx_usb->imx_ep[i];
1008                 imx_flush(imx_ep);
1009                 imx_ep->stopped = 1;
1010                 imx_ep_irq_disable(imx_ep);
1011                 nuke(imx_ep, -ESHUTDOWN);
1012         }
1013
1014         imx_usb->cfg = 0;
1015         imx_usb->intf = 0;
1016         imx_usb->alt = 0;
1017
1018         if (driver)
1019                 driver->disconnect(&imx_usb->gadget);
1020 }
1021
1022 /*******************************************************************************
1023  * Interrupt handlers
1024  *******************************************************************************
1025  */
1026
1027 /*
1028  * Called when timer expires.
1029  * Timer is started when CFG_CHG is received.
1030  */
1031 static void handle_config(unsigned long data)
1032 {
1033         struct imx_udc_struct *imx_usb = (void *)data;
1034         struct usb_ctrlrequest u;
1035         int temp, cfg, intf, alt;
1036
1037         local_irq_disable();
1038
1039         temp = __raw_readl(imx_usb->base + USB_STAT);
1040         cfg  = (temp & STAT_CFG) >> 5;
1041         intf = (temp & STAT_INTF) >> 3;
1042         alt  =  temp & STAT_ALTSET;
1043
1044         D_REQ(imx_usb->dev,
1045                 "<%s> orig config C=%d, I=%d, A=%d / "
1046                 "req config C=%d, I=%d, A=%d\n",
1047                 __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
1048                 cfg, intf, alt);
1049
1050         if (cfg == 1 || cfg == 2) {
1051
1052                 if (imx_usb->cfg != cfg) {
1053                         u.bRequest = USB_REQ_SET_CONFIGURATION;
1054                         u.bRequestType = USB_DIR_OUT |
1055                                         USB_TYPE_STANDARD |
1056                                         USB_RECIP_DEVICE;
1057                         u.wValue = cfg;
1058                         u.wIndex = 0;
1059                         u.wLength = 0;
1060                         imx_usb->cfg = cfg;
1061                         imx_usb->driver->setup(&imx_usb->gadget, &u);
1062
1063                 }
1064                 if (imx_usb->intf != intf || imx_usb->alt != alt) {
1065                         u.bRequest = USB_REQ_SET_INTERFACE;
1066                         u.bRequestType = USB_DIR_OUT |
1067                                           USB_TYPE_STANDARD |
1068                                           USB_RECIP_INTERFACE;
1069                         u.wValue = alt;
1070                         u.wIndex = intf;
1071                         u.wLength = 0;
1072                         imx_usb->intf = intf;
1073                         imx_usb->alt = alt;
1074                         imx_usb->driver->setup(&imx_usb->gadget, &u);
1075                 }
1076         }
1077
1078         imx_usb->set_config = 0;
1079
1080         local_irq_enable();
1081 }
1082
1083 static irqreturn_t imx_udc_irq(int irq, void *dev)
1084 {
1085         struct imx_udc_struct *imx_usb = dev;
1086         int intr = __raw_readl(imx_usb->base + USB_INTR);
1087         int temp;
1088
1089         if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
1090                         | INTR_RESET_STOP | INTR_CFG_CHG)) {
1091                                 dump_intr(__func__, intr, imx_usb->dev);
1092                                 dump_usb_stat(__func__, imx_usb);
1093         }
1094
1095         if (!imx_usb->driver)
1096                 goto end_irq;
1097
1098         if (intr & INTR_SOF) {
1099                 /* Copy from Freescale BSP.
1100                    We must enable SOF intr and set CMDOVER.
1101                    Datasheet don't specifiy this action, but it
1102                    is done in Freescale BSP, so just copy it.
1103                 */
1104                 if (imx_usb->ep0state == EP0_IDLE) {
1105                         temp = __raw_readl(imx_usb->base + USB_CTRL);
1106                         __raw_writel(temp | CTRL_CMDOVER,
1107                                                 imx_usb->base + USB_CTRL);
1108                 }
1109         }
1110
1111         if (intr & INTR_CFG_CHG) {
1112                 /* A workaround of serious IMX UDC bug.
1113                    Handling of CFG_CHG should be delayed for some time, because
1114                    IMX does not NACK the host when CFG_CHG interrupt is pending.
1115                    There is no time to handle current CFG_CHG
1116                    if next CFG_CHG or SETUP packed is send immediately.
1117                    We have to clear CFG_CHG, start the timer and
1118                    NACK the host by setting CTRL_CMDOVER
1119                    if it sends any SETUP packet.
1120                    When timer expires, handler is called to handle configuration
1121                    changes. While CFG_CHG is not handled (set_config=1),
1122                    we must NACK the host to every SETUP packed.
1123                    This delay prevents from going out of sync with host.
1124                  */
1125                 __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
1126                 imx_usb->set_config = 1;
1127                 mod_timer(&imx_usb->timer, jiffies + 5);
1128                 goto end_irq;
1129         }
1130
1131         if (intr & INTR_WAKEUP) {
1132                 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
1133                         && imx_usb->driver && imx_usb->driver->resume)
1134                                 imx_usb->driver->resume(&imx_usb->gadget);
1135                 imx_usb->set_config = 0;
1136                 del_timer(&imx_usb->timer);
1137                 imx_usb->gadget.speed = USB_SPEED_FULL;
1138         }
1139
1140         if (intr & INTR_SUSPEND) {
1141                 if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
1142                         && imx_usb->driver && imx_usb->driver->suspend)
1143                                 imx_usb->driver->suspend(&imx_usb->gadget);
1144                 imx_usb->set_config = 0;
1145                 del_timer(&imx_usb->timer);
1146                 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1147         }
1148
1149         if (intr & INTR_RESET_START) {
1150                 __raw_writel(intr, imx_usb->base + USB_INTR);
1151                 udc_stop_activity(imx_usb, imx_usb->driver);
1152                 imx_usb->set_config = 0;
1153                 del_timer(&imx_usb->timer);
1154                 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1155         }
1156
1157         if (intr & INTR_RESET_STOP)
1158                 imx_usb->gadget.speed = USB_SPEED_FULL;
1159
1160 end_irq:
1161         __raw_writel(intr, imx_usb->base + USB_INTR);
1162         return IRQ_HANDLED;
1163 }
1164
1165 static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
1166 {
1167         struct imx_udc_struct *imx_usb = dev;
1168         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
1169         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
1170
1171         dump_ep_intr(__func__, 0, intr, imx_usb->dev);
1172
1173         if (!imx_usb->driver) {
1174                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1175                 return IRQ_HANDLED;
1176         }
1177
1178         /* DEVREQ has highest priority */
1179         if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
1180                 handle_ep0_devreq(imx_usb);
1181         /* Seem i.MX is missing EOF interrupt sometimes.
1182          * Therefore we don't monitor EOF.
1183          * We call handle_ep0() only if a request is queued for ep0.
1184          */
1185         else if (!list_empty(&imx_ep->queue))
1186                 handle_ep0(imx_ep);
1187
1188         __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1189
1190         return IRQ_HANDLED;
1191 }
1192
1193 static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
1194 {
1195         struct imx_udc_struct *imx_usb = dev;
1196         struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
1197         int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1198
1199         dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
1200
1201         if (!imx_usb->driver) {
1202                 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1203                 return IRQ_HANDLED;
1204         }
1205
1206         handle_ep(imx_ep);
1207
1208         __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1209
1210         return IRQ_HANDLED;
1211 }
1212
1213 irq_handler_t intr_handler(int i)
1214 {
1215         switch (i) {
1216         case 0:
1217                 return imx_udc_ctrl_irq;
1218         case 1:
1219         case 2:
1220         case 3:
1221         case 4:
1222         case 5:
1223                 return imx_udc_bulk_irq;
1224         default:
1225                 return imx_udc_irq;
1226         }
1227 }
1228
1229 /*******************************************************************************
1230  * Static defined IMX UDC structure
1231  *******************************************************************************
1232  */
1233
1234 static const struct usb_gadget_ops imx_udc_ops = {
1235         .get_frame       = imx_udc_get_frame,
1236         .wakeup          = imx_udc_wakeup,
1237 };
1238
1239 static struct imx_udc_struct controller = {
1240         .gadget = {
1241                 .ops            = &imx_udc_ops,
1242                 .ep0            = &controller.imx_ep[0].ep,
1243                 .name           = driver_name,
1244                 .dev = {
1245                         .init_name      = "gadget",
1246                 },
1247         },
1248
1249         .imx_ep[0] = {
1250                 .ep = {
1251                         .name           = ep0name,
1252                         .ops            = &imx_ep_ops,
1253                         .maxpacket      = 32,
1254                 },
1255                 .imx_usb                = &controller,
1256                 .fifosize               = 32,
1257                 .bEndpointAddress       = 0,
1258                 .bmAttributes           = USB_ENDPOINT_XFER_CONTROL,
1259          },
1260         .imx_ep[1] = {
1261                 .ep = {
1262                         .name           = "ep1in-bulk",
1263                         .ops            = &imx_ep_ops,
1264                         .maxpacket      = 64,
1265                 },
1266                 .imx_usb                = &controller,
1267                 .fifosize               = 64,
1268                 .bEndpointAddress       = USB_DIR_IN | 1,
1269                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1270          },
1271         .imx_ep[2] = {
1272                 .ep = {
1273                         .name           = "ep2out-bulk",
1274                         .ops            = &imx_ep_ops,
1275                         .maxpacket      = 64,
1276                 },
1277                 .imx_usb                = &controller,
1278                 .fifosize               = 64,
1279                 .bEndpointAddress       = USB_DIR_OUT | 2,
1280                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1281          },
1282         .imx_ep[3] = {
1283                 .ep = {
1284                         .name           = "ep3out-bulk",
1285                         .ops            = &imx_ep_ops,
1286                         .maxpacket      = 32,
1287                 },
1288                 .imx_usb                = &controller,
1289                 .fifosize               = 32,
1290                 .bEndpointAddress       = USB_DIR_OUT | 3,
1291                 .bmAttributes           = USB_ENDPOINT_XFER_BULK,
1292          },
1293         .imx_ep[4] = {
1294                 .ep = {
1295                         .name           = "ep4in-int",
1296                         .ops            = &imx_ep_ops,
1297                         .maxpacket      = 32,
1298                  },
1299                 .imx_usb                = &controller,
1300                 .fifosize               = 32,
1301                 .bEndpointAddress       = USB_DIR_IN | 4,
1302                 .bmAttributes           = USB_ENDPOINT_XFER_INT,
1303          },
1304         .imx_ep[5] = {
1305                 .ep = {
1306                         .name           = "ep5out-int",
1307                         .ops            = &imx_ep_ops,
1308                         .maxpacket      = 32,
1309                 },
1310                 .imx_usb                = &controller,
1311                 .fifosize               = 32,
1312                 .bEndpointAddress       = USB_DIR_OUT | 5,
1313                 .bmAttributes           = USB_ENDPOINT_XFER_INT,
1314          },
1315 };
1316
1317 /*******************************************************************************
1318  * USB gadged driver functions
1319  *******************************************************************************
1320  */
1321 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1322 {
1323         struct imx_udc_struct *imx_usb = &controller;
1324         int retval;
1325
1326         if (!driver
1327                 || driver->speed < USB_SPEED_FULL
1328                 || !driver->bind
1329                 || !driver->disconnect
1330                 || !driver->setup)
1331                         return -EINVAL;
1332         if (!imx_usb)
1333                 return -ENODEV;
1334         if (imx_usb->driver)
1335                 return -EBUSY;
1336
1337         /* first hook up the driver ... */
1338         imx_usb->driver = driver;
1339         imx_usb->gadget.dev.driver = &driver->driver;
1340
1341         retval = device_add(&imx_usb->gadget.dev);
1342         if (retval)
1343                 goto fail;
1344         retval = driver->bind(&imx_usb->gadget);
1345         if (retval) {
1346                 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
1347                         __func__, driver->driver.name, retval);
1348                 device_del(&imx_usb->gadget.dev);
1349
1350                 goto fail;
1351         }
1352
1353         D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
1354                 __func__, driver->driver.name);
1355
1356         imx_udc_enable(imx_usb);
1357
1358         return 0;
1359 fail:
1360         imx_usb->driver = NULL;
1361         imx_usb->gadget.dev.driver = NULL;
1362         return retval;
1363 }
1364 EXPORT_SYMBOL(usb_gadget_register_driver);
1365
1366 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1367 {
1368         struct imx_udc_struct *imx_usb = &controller;
1369
1370         if (!imx_usb)
1371                 return -ENODEV;
1372         if (!driver || driver != imx_usb->driver || !driver->unbind)
1373                 return -EINVAL;
1374
1375         udc_stop_activity(imx_usb, driver);
1376         imx_udc_disable(imx_usb);
1377         del_timer(&imx_usb->timer);
1378
1379         driver->unbind(&imx_usb->gadget);
1380         imx_usb->gadget.dev.driver = NULL;
1381         imx_usb->driver = NULL;
1382
1383         device_del(&imx_usb->gadget.dev);
1384
1385         D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
1386                 __func__, driver->driver.name);
1387
1388         return 0;
1389 }
1390 EXPORT_SYMBOL(usb_gadget_unregister_driver);
1391
1392 /*******************************************************************************
1393  * Module functions
1394  *******************************************************************************
1395  */
1396
1397 static int __init imx_udc_probe(struct platform_device *pdev)
1398 {
1399         struct imx_udc_struct *imx_usb = &controller;
1400         struct resource *res;
1401         struct imxusb_platform_data *pdata;
1402         struct clk *clk;
1403         void __iomem *base;
1404         int ret = 0;
1405         int i;
1406         resource_size_t res_size;
1407
1408         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1409         if (!res) {
1410                 dev_err(&pdev->dev, "can't get device resources\n");
1411                 return -ENODEV;
1412         }
1413
1414         pdata = pdev->dev.platform_data;
1415         if (!pdata) {
1416                 dev_err(&pdev->dev, "driver needs platform data\n");
1417                 return -ENODEV;
1418         }
1419
1420         res_size = resource_size(res);
1421         if (!request_mem_region(res->start, res_size, res->name)) {
1422                 dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
1423                         res_size, res->start);
1424                 return -ENOMEM;
1425         }
1426
1427         if (pdata->init) {
1428                 ret = pdata->init(&pdev->dev);
1429                 if (ret)
1430                         goto fail0;
1431         }
1432
1433         base = ioremap(res->start, res_size);
1434         if (!base) {
1435                 dev_err(&pdev->dev, "ioremap failed\n");
1436                 ret = -EIO;
1437                 goto fail1;
1438         }
1439
1440         clk = clk_get(NULL, "usbd_clk");
1441         if (IS_ERR(clk)) {
1442                 ret = PTR_ERR(clk);
1443                 dev_err(&pdev->dev, "can't get USB clock\n");
1444                 goto fail2;
1445         }
1446         clk_enable(clk);
1447
1448         if (clk_get_rate(clk) != 48000000) {
1449                 D_INI(&pdev->dev,
1450                         "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
1451                         (int)clk_get_rate(clk));
1452                 if (clk_set_rate(clk, 48000000)) {
1453                         dev_err(&pdev->dev,
1454                                 "Unable to set correct USB clock (48MHz)\n");
1455                         ret = -EIO;
1456                         goto fail3;
1457                 }
1458         }
1459
1460         for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1461                 imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
1462                 if (imx_usb->usbd_int[i] < 0) {
1463                         dev_err(&pdev->dev, "can't get irq number\n");
1464                         ret = -ENODEV;
1465                         goto fail3;
1466                 }
1467         }
1468
1469         for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1470                 ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
1471                                      IRQF_DISABLED, driver_name, imx_usb);
1472                 if (ret) {
1473                         dev_err(&pdev->dev, "can't get irq %i, err %d\n",
1474                                 imx_usb->usbd_int[i], ret);
1475                         for (--i; i >= 0; i--)
1476                                 free_irq(imx_usb->usbd_int[i], imx_usb);
1477                         goto fail3;
1478                 }
1479         }
1480
1481         imx_usb->res = res;
1482         imx_usb->base = base;
1483         imx_usb->clk = clk;
1484         imx_usb->dev = &pdev->dev;
1485
1486         device_initialize(&imx_usb->gadget.dev);
1487
1488         imx_usb->gadget.dev.parent = &pdev->dev;
1489         imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
1490
1491         platform_set_drvdata(pdev, imx_usb);
1492
1493         usb_init_data(imx_usb);
1494         imx_udc_init(imx_usb);
1495
1496         init_timer(&imx_usb->timer);
1497         imx_usb->timer.function = handle_config;
1498         imx_usb->timer.data = (unsigned long)imx_usb;
1499
1500         return 0;
1501
1502 fail3:
1503         clk_put(clk);
1504         clk_disable(clk);
1505 fail2:
1506         iounmap(base);
1507 fail1:
1508         if (pdata->exit)
1509                 pdata->exit(&pdev->dev);
1510 fail0:
1511         release_mem_region(res->start, res_size);
1512         return ret;
1513 }
1514
1515 static int __exit imx_udc_remove(struct platform_device *pdev)
1516 {
1517         struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
1518         struct imxusb_platform_data *pdata = pdev->dev.platform_data;
1519         int i;
1520
1521         imx_udc_disable(imx_usb);
1522         del_timer(&imx_usb->timer);
1523
1524         for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1525                 free_irq(imx_usb->usbd_int[i], imx_usb);
1526
1527         clk_put(imx_usb->clk);
1528         clk_disable(imx_usb->clk);
1529         iounmap(imx_usb->base);
1530
1531         release_mem_region(imx_usb->res->start, resource_size(imx_usb->res));
1532
1533         if (pdata->exit)
1534                 pdata->exit(&pdev->dev);
1535
1536         platform_set_drvdata(pdev, NULL);
1537
1538         return 0;
1539 }
1540
1541 /*----------------------------------------------------------------------------*/
1542
1543 #ifdef  CONFIG_PM
1544 #define imx_udc_suspend NULL
1545 #define imx_udc_resume  NULL
1546 #else
1547 #define imx_udc_suspend NULL
1548 #define imx_udc_resume  NULL
1549 #endif
1550
1551 /*----------------------------------------------------------------------------*/
1552
1553 static struct platform_driver udc_driver = {
1554         .driver         = {
1555                 .name   = driver_name,
1556                 .owner  = THIS_MODULE,
1557         },
1558         .remove         = __exit_p(imx_udc_remove),
1559         .suspend        = imx_udc_suspend,
1560         .resume         = imx_udc_resume,
1561 };
1562
1563 static int __init udc_init(void)
1564 {
1565         return platform_driver_probe(&udc_driver, imx_udc_probe);
1566 }
1567 module_init(udc_init);
1568
1569 static void __exit udc_exit(void)
1570 {
1571         platform_driver_unregister(&udc_driver);
1572 }
1573 module_exit(udc_exit);
1574
1575 MODULE_DESCRIPTION("IMX USB Device Controller driver");
1576 MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
1577 MODULE_LICENSE("GPL");
1578 MODULE_ALIAS("platform:imx_udc");