Pileus Git - ~andy/linux/blob - drivers/usb/gadget/langwell_udc.c

   1 /*
   2  * Intel Langwell USB Device Controller driver
   3  * Copyright (C) 2008-2009, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  */
   9
  10
  11 /* #undef       DEBUG */
  12 /* #undef       VERBOSE_DEBUG */
  13
  14 #include <linux/module.h>
  15 #include <linux/pci.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/kernel.h>
  18 #include <linux/delay.h>
  19 #include <linux/ioport.h>
  20 #include <linux/sched.h>
  21 #include <linux/slab.h>
  22 #include <linux/errno.h>
  23 #include <linux/init.h>
  24 #include <linux/timer.h>
  25 #include <linux/list.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/device.h>
  29 #include <linux/usb/ch9.h>
  30 #include <linux/usb/gadget.h>
  31 #include <linux/usb/otg.h>
  32 #include <linux/pm.h>
  33 #include <linux/io.h>
  34 #include <linux/irq.h>
  35 #include <asm/system.h>
  36 #include <asm/unaligned.h>
  37
  38 #include "langwell_udc.h"
  39
  40
  41 #define DRIVER_DESC             "Intel Langwell USB Device Controller driver"
  42 #define DRIVER_VERSION          "16 May 2009"
  43
  44 static const char driver_name[] = "langwell_udc";
  45 static const char driver_desc[] = DRIVER_DESC;
  46
  47
  48 /* for endpoint 0 operations */
  49 static const struct usb_endpoint_descriptor
  50 langwell_ep0_desc = {
  51         .bLength =              USB_DT_ENDPOINT_SIZE,
  52         .bDescriptorType =      USB_DT_ENDPOINT,
  53         .bEndpointAddress =     0,
  54         .bmAttributes =         USB_ENDPOINT_XFER_CONTROL,
  55         .wMaxPacketSize =       EP0_MAX_PKT_SIZE,
  56 };
  57
  58
  59 /*-------------------------------------------------------------------------*/
  60 /* debugging */
  61
  62 #ifdef  VERBOSE_DEBUG
  63 static inline void print_all_registers(struct langwell_udc *dev)
  64 {
  65         int     i;
  66
  67         /* Capability Registers */
  68         dev_dbg(&dev->pdev->dev,
  69                 "Capability Registers (offset: 0x%04x, length: 0x%08x)\n",
  70                 CAP_REG_OFFSET, (u32)sizeof(struct langwell_cap_regs));
  71         dev_dbg(&dev->pdev->dev, "caplength=0x%02x\n",
  72                         readb(&dev->cap_regs->caplength));
  73         dev_dbg(&dev->pdev->dev, "hciversion=0x%04x\n",
  74                         readw(&dev->cap_regs->hciversion));
  75         dev_dbg(&dev->pdev->dev, "hcsparams=0x%08x\n",
  76                         readl(&dev->cap_regs->hcsparams));
  77         dev_dbg(&dev->pdev->dev, "hccparams=0x%08x\n",
  78                         readl(&dev->cap_regs->hccparams));
  79         dev_dbg(&dev->pdev->dev, "dciversion=0x%04x\n",
  80                         readw(&dev->cap_regs->dciversion));
  81         dev_dbg(&dev->pdev->dev, "dccparams=0x%08x\n",
  82                         readl(&dev->cap_regs->dccparams));
  83
  84         /* Operational Registers */
  85         dev_dbg(&dev->pdev->dev,
  86                 "Operational Registers (offset: 0x%04x, length: 0x%08x)\n",
  87                 OP_REG_OFFSET, (u32)sizeof(struct langwell_op_regs));
  88         dev_dbg(&dev->pdev->dev, "extsts=0x%08x\n",
  89                         readl(&dev->op_regs->extsts));
  90         dev_dbg(&dev->pdev->dev, "extintr=0x%08x\n",
  91                         readl(&dev->op_regs->extintr));
  92         dev_dbg(&dev->pdev->dev, "usbcmd=0x%08x\n",
  93                         readl(&dev->op_regs->usbcmd));
  94         dev_dbg(&dev->pdev->dev, "usbsts=0x%08x\n",
  95                         readl(&dev->op_regs->usbsts));
  96         dev_dbg(&dev->pdev->dev, "usbintr=0x%08x\n",
  97                         readl(&dev->op_regs->usbintr));
  98         dev_dbg(&dev->pdev->dev, "frindex=0x%08x\n",
  99                         readl(&dev->op_regs->frindex));
 100         dev_dbg(&dev->pdev->dev, "ctrldssegment=0x%08x\n",
 101                         readl(&dev->op_regs->ctrldssegment));
 102         dev_dbg(&dev->pdev->dev, "deviceaddr=0x%08x\n",
 103                         readl(&dev->op_regs->deviceaddr));
 104         dev_dbg(&dev->pdev->dev, "endpointlistaddr=0x%08x\n",
 105                         readl(&dev->op_regs->endpointlistaddr));
 106         dev_dbg(&dev->pdev->dev, "ttctrl=0x%08x\n",
 107                         readl(&dev->op_regs->ttctrl));
 108         dev_dbg(&dev->pdev->dev, "burstsize=0x%08x\n",
 109                         readl(&dev->op_regs->burstsize));
 110         dev_dbg(&dev->pdev->dev, "txfilltuning=0x%08x\n",
 111                         readl(&dev->op_regs->txfilltuning));
 112         dev_dbg(&dev->pdev->dev, "txttfilltuning=0x%08x\n",
 113                         readl(&dev->op_regs->txttfilltuning));
 114         dev_dbg(&dev->pdev->dev, "ic_usb=0x%08x\n",
 115                         readl(&dev->op_regs->ic_usb));
 116         dev_dbg(&dev->pdev->dev, "ulpi_viewport=0x%08x\n",
 117                         readl(&dev->op_regs->ulpi_viewport));
 118         dev_dbg(&dev->pdev->dev, "configflag=0x%08x\n",
 119                         readl(&dev->op_regs->configflag));
 120         dev_dbg(&dev->pdev->dev, "portsc1=0x%08x\n",
 121                         readl(&dev->op_regs->portsc1));
 122         dev_dbg(&dev->pdev->dev, "devlc=0x%08x\n",
 123                         readl(&dev->op_regs->devlc));
 124         dev_dbg(&dev->pdev->dev, "otgsc=0x%08x\n",
 125                         readl(&dev->op_regs->otgsc));
 126         dev_dbg(&dev->pdev->dev, "usbmode=0x%08x\n",
 127                         readl(&dev->op_regs->usbmode));
 128         dev_dbg(&dev->pdev->dev, "endptnak=0x%08x\n",
 129                         readl(&dev->op_regs->endptnak));
 130         dev_dbg(&dev->pdev->dev, "endptnaken=0x%08x\n",
 131                         readl(&dev->op_regs->endptnaken));
 132         dev_dbg(&dev->pdev->dev, "endptsetupstat=0x%08x\n",
 133                         readl(&dev->op_regs->endptsetupstat));
 134         dev_dbg(&dev->pdev->dev, "endptprime=0x%08x\n",
 135                         readl(&dev->op_regs->endptprime));
 136         dev_dbg(&dev->pdev->dev, "endptflush=0x%08x\n",
 137                         readl(&dev->op_regs->endptflush));
 138         dev_dbg(&dev->pdev->dev, "endptstat=0x%08x\n",
 139                         readl(&dev->op_regs->endptstat));
 140         dev_dbg(&dev->pdev->dev, "endptcomplete=0x%08x\n",
 141                         readl(&dev->op_regs->endptcomplete));
 142
 143         for (i = 0; i < dev->ep_max / 2; i++) {
 144                 dev_dbg(&dev->pdev->dev, "endptctrl[%d]=0x%08x\n",
 145                                 i, readl(&dev->op_regs->endptctrl[i]));
 146         }
 147 }
 148 #else
 149
 150 #define print_all_registers(dev)        do { } while (0)
 151
 152 #endif /* VERBOSE_DEBUG */
 153
 154
 155 /*-------------------------------------------------------------------------*/
 156
 157 #define is_in(ep)       (((ep)->ep_num == 0) ? ((ep)->dev->ep0_dir ==   \
 158                         USB_DIR_IN) : (usb_endpoint_dir_in((ep)->desc)))
 159
 160 #define DIR_STRING(ep)  (is_in(ep) ? "in" : "out")
 161
 162
 163 static char *type_string(const struct usb_endpoint_descriptor *desc)
 164 {
 165         switch (usb_endpoint_type(desc)) {
 166         case USB_ENDPOINT_XFER_BULK:
 167                 return "bulk";
 168         case USB_ENDPOINT_XFER_ISOC:
 169                 return "iso";
 170         case USB_ENDPOINT_XFER_INT:
 171                 return "int";
 172         };
 173
 174         return "control";
 175 }
 176
 177
 178 /* configure endpoint control registers */
 179 static void ep_reset(struct langwell_ep *ep, unsigned char ep_num,
 180                 unsigned char is_in, unsigned char ep_type)
 181 {
 182         struct langwell_udc     *dev;
 183         u32                     endptctrl;
 184
 185         dev = ep->dev;
 186         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 187
 188         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
 189         if (is_in) {    /* TX */
 190                 if (ep_num)
 191                         endptctrl |= EPCTRL_TXR;
 192                 endptctrl |= EPCTRL_TXE;
 193                 endptctrl |= ep_type << EPCTRL_TXT_SHIFT;
 194         } else {        /* RX */
 195                 if (ep_num)
 196                         endptctrl |= EPCTRL_RXR;
 197                 endptctrl |= EPCTRL_RXE;
 198                 endptctrl |= ep_type << EPCTRL_RXT_SHIFT;
 199         }
 200
 201         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 202
 203         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 204 }
 205
 206
 207 /* reset ep0 dQH and endptctrl */
 208 static void ep0_reset(struct langwell_udc *dev)
 209 {
 210         struct langwell_ep      *ep;
 211         int                     i;
 212
 213         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 214
 215         /* ep0 in and out */
 216         for (i = 0; i < 2; i++) {
 217                 ep = &dev->ep[i];
 218                 ep->dev = dev;
 219
 220                 /* ep0 dQH */
 221                 ep->dqh = &dev->ep_dqh[i];
 222
 223                 /* configure ep0 endpoint capabilities in dQH */
 224                 ep->dqh->dqh_ios = 1;
 225                 ep->dqh->dqh_mpl = EP0_MAX_PKT_SIZE;
 226
 227                 /* enable ep0-in HW zero length termination select */
 228                 if (is_in(ep))
 229                         ep->dqh->dqh_zlt = 0;
 230                 ep->dqh->dqh_mult = 0;
 231
 232                 ep->dqh->dtd_next = DTD_TERM;
 233
 234                 /* configure ep0 control registers */
 235                 ep_reset(&dev->ep[0], 0, i, USB_ENDPOINT_XFER_CONTROL);
 236         }
 237
 238         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 239 }
 240
 241
 242 /*-------------------------------------------------------------------------*/
 243
 244 /* endpoints operations */
 245
 246 /* configure endpoint, making it usable */
 247 static int langwell_ep_enable(struct usb_ep *_ep,
 248                 const struct usb_endpoint_descriptor *desc)
 249 {
 250         struct langwell_udc     *dev;
 251         struct langwell_ep      *ep;
 252         u16                     max = 0;
 253         unsigned long           flags;
 254         int                     i, retval = 0;
 255         unsigned char           zlt, ios = 0, mult = 0;
 256
 257         ep = container_of(_ep, struct langwell_ep, ep);
 258         dev = ep->dev;
 259         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 260
 261         if (!_ep || !desc || ep->desc
 262                         || desc->bDescriptorType != USB_DT_ENDPOINT)
 263                 return -EINVAL;
 264
 265         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
 266                 return -ESHUTDOWN;
 267
 268         max = usb_endpoint_maxp(desc);
 269
 270         /*
 271          * disable HW zero length termination select
 272          * driver handles zero length packet through req->req.zero
 273          */
 274         zlt = 1;
 275
 276         /*
 277          * sanity check type, direction, address, and then
 278          * initialize the endpoint capabilities fields in dQH
 279          */
 280         switch (usb_endpoint_type(desc)) {
 281         case USB_ENDPOINT_XFER_CONTROL:
 282                 ios = 1;
 283                 break;
 284         case USB_ENDPOINT_XFER_BULK:
 285                 if ((dev->gadget.speed == USB_SPEED_HIGH
 286                                         && max != 512)
 287                                 || (dev->gadget.speed == USB_SPEED_FULL
 288                                         && max > 64)) {
 289                         goto done;
 290                 }
 291                 break;
 292         case USB_ENDPOINT_XFER_INT:
 293                 if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
 294                         goto done;
 295
 296                 switch (dev->gadget.speed) {
 297                 case USB_SPEED_HIGH:
 298                         if (max <= 1024)
 299                                 break;
 300                 case USB_SPEED_FULL:
 301                         if (max <= 64)
 302                                 break;
 303                 default:
 304                         if (max <= 8)
 305                                 break;
 306                         goto done;
 307                 }
 308                 break;
 309         case USB_ENDPOINT_XFER_ISOC:
 310                 if (strstr(ep->ep.name, "-bulk")
 311                                 || strstr(ep->ep.name, "-int"))
 312                         goto done;
 313
 314                 switch (dev->gadget.speed) {
 315                 case USB_SPEED_HIGH:
 316                         if (max <= 1024)
 317                                 break;
 318                 case USB_SPEED_FULL:
 319                         if (max <= 1023)
 320                                 break;
 321                 default:
 322                         goto done;
 323                 }
 324                 /*
 325                  * FIXME:
 326                  * calculate transactions needed for high bandwidth iso
 327                  */
 328                 mult = (unsigned char)(1 + ((max >> 11) & 0x03));
 329                 max = max & 0x8ff;      /* bit 0~10 */
 330                 /* 3 transactions at most */
 331                 if (mult > 3)
 332                         goto done;
 333                 break;
 334         default:
 335                 goto done;
 336         }
 337
 338         spin_lock_irqsave(&dev->lock, flags);
 339
 340         ep->ep.maxpacket = max;
 341         ep->desc = desc;
 342         ep->stopped = 0;
 343         ep->ep_num = usb_endpoint_num(desc);
 344
 345         /* ep_type */
 346         ep->ep_type = usb_endpoint_type(desc);
 347
 348         /* configure endpoint control registers */
 349         ep_reset(ep, ep->ep_num, is_in(ep), ep->ep_type);
 350
 351         /* configure endpoint capabilities in dQH */
 352         i = ep->ep_num * 2 + is_in(ep);
 353         ep->dqh = &dev->ep_dqh[i];
 354         ep->dqh->dqh_ios = ios;
 355         ep->dqh->dqh_mpl = cpu_to_le16(max);
 356         ep->dqh->dqh_zlt = zlt;
 357         ep->dqh->dqh_mult = mult;
 358         ep->dqh->dtd_next = DTD_TERM;
 359
 360         dev_dbg(&dev->pdev->dev, "enabled %s (ep%d%s-%s), max %04x\n",
 361                         _ep->name,
 362                         ep->ep_num,
 363                         DIR_STRING(ep),
 364                         type_string(desc),
 365                         max);
 366
 367         spin_unlock_irqrestore(&dev->lock, flags);
 368 done:
 369         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 370         return retval;
 371 }
 372
 373
 374 /*-------------------------------------------------------------------------*/
 375
 376 /* retire a request */
 377 static void done(struct langwell_ep *ep, struct langwell_request *req,
 378                 int status)
 379 {
 380         struct langwell_udc     *dev = ep->dev;
 381         unsigned                stopped = ep->stopped;
 382         struct langwell_dtd     *curr_dtd, *next_dtd;
 383         int                     i;
 384
 385         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 386
 387         /* remove the req from ep->queue */
 388         list_del_init(&req->queue);
 389
 390         if (req->req.status == -EINPROGRESS)
 391                 req->req.status = status;
 392         else
 393                 status = req->req.status;
 394
 395         /* free dTD for the request */
 396         next_dtd = req->head;
 397         for (i = 0; i < req->dtd_count; i++) {
 398                 curr_dtd = next_dtd;
 399                 if (i != req->dtd_count - 1)
 400                         next_dtd = curr_dtd->next_dtd_virt;
 401                 dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma);
 402         }
 403
 404         usb_gadget_unmap_request(&dev->gadget, &req->req, is_in(ep));
 405
 406         if (status != -ESHUTDOWN)
 407                 dev_dbg(&dev->pdev->dev,
 408                                 "complete %s, req %p, stat %d, len %u/%u\n",
 409                                 ep->ep.name, &req->req, status,
 410                                 req->req.actual, req->req.length);
 411
 412         /* don't modify queue heads during completion callback */
 413         ep->stopped = 1;
 414
 415         spin_unlock(&dev->lock);
 416         /* complete routine from gadget driver */
 417         if (req->req.complete)
 418                 req->req.complete(&ep->ep, &req->req);
 419
 420         spin_lock(&dev->lock);
 421         ep->stopped = stopped;
 422
 423         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 424 }
 425
 426
 427 static void langwell_ep_fifo_flush(struct usb_ep *_ep);
 428
 429 /* delete all endpoint requests, called with spinlock held */
 430 static void nuke(struct langwell_ep *ep, int status)
 431 {
 432         /* called with spinlock held */
 433         ep->stopped = 1;
 434
 435         /* endpoint fifo flush */
 436         if (&ep->ep && ep->desc)
 437                 langwell_ep_fifo_flush(&ep->ep);
 438
 439         while (!list_empty(&ep->queue)) {
 440                 struct langwell_request *req = NULL;
 441                 req = list_entry(ep->queue.next, struct langwell_request,
 442                                 queue);
 443                 done(ep, req, status);
 444         }
 445 }
 446
 447
 448 /*-------------------------------------------------------------------------*/
 449
 450 /* endpoint is no longer usable */
 451 static int langwell_ep_disable(struct usb_ep *_ep)
 452 {
 453         struct langwell_ep      *ep;
 454         unsigned long           flags;
 455         struct langwell_udc     *dev;
 456         int                     ep_num;
 457         u32                     endptctrl;
 458
 459         ep = container_of(_ep, struct langwell_ep, ep);
 460         dev = ep->dev;
 461         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 462
 463         if (!_ep || !ep->desc)
 464                 return -EINVAL;
 465
 466         spin_lock_irqsave(&dev->lock, flags);
 467
 468         /* disable endpoint control register */
 469         ep_num = ep->ep_num;
 470         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
 471         if (is_in(ep))
 472                 endptctrl &= ~EPCTRL_TXE;
 473         else
 474                 endptctrl &= ~EPCTRL_RXE;
 475         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 476
 477         /* nuke all pending requests (does flush) */
 478         nuke(ep, -ESHUTDOWN);
 479
 480         ep->desc = NULL;
 481         ep->ep.desc = NULL;
 482         ep->stopped = 1;
 483
 484         spin_unlock_irqrestore(&dev->lock, flags);
 485
 486         dev_dbg(&dev->pdev->dev, "disabled %s\n", _ep->name);
 487         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 488
 489         return 0;
 490 }
 491
 492
 493 /* allocate a request object to use with this endpoint */
 494 static struct usb_request *langwell_alloc_request(struct usb_ep *_ep,
 495                 gfp_t gfp_flags)
 496 {
 497         struct langwell_ep      *ep;
 498         struct langwell_udc     *dev;
 499         struct langwell_request *req = NULL;
 500
 501         if (!_ep)
 502                 return NULL;
 503
 504         ep = container_of(_ep, struct langwell_ep, ep);
 505         dev = ep->dev;
 506         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 507
 508         req = kzalloc(sizeof(*req), gfp_flags);
 509         if (!req)
 510                 return NULL;
 511
 512         req->req.dma = DMA_ADDR_INVALID;
 513         INIT_LIST_HEAD(&req->queue);
 514
 515         dev_vdbg(&dev->pdev->dev, "alloc request for %s\n", _ep->name);
 516         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 517         return &req->req;
 518 }
 519
 520
 521 /* free a request object */
 522 static void langwell_free_request(struct usb_ep *_ep,
 523                 struct usb_request *_req)
 524 {
 525         struct langwell_ep      *ep;
 526         struct langwell_udc     *dev;
 527         struct langwell_request *req = NULL;
 528
 529         ep = container_of(_ep, struct langwell_ep, ep);
 530         dev = ep->dev;
 531         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 532
 533         if (!_ep || !_req)
 534                 return;
 535
 536         req = container_of(_req, struct langwell_request, req);
 537         WARN_ON(!list_empty(&req->queue));
 538
 539         if (_req)
 540                 kfree(req);
 541
 542         dev_vdbg(&dev->pdev->dev, "free request for %s\n", _ep->name);
 543         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 544 }
 545
 546
 547 /*-------------------------------------------------------------------------*/
 548
 549 /* queue dTD and PRIME endpoint */
 550 static int queue_dtd(struct langwell_ep *ep, struct langwell_request *req)
 551 {
 552         u32                     bit_mask, usbcmd, endptstat, dtd_dma;
 553         u8                      dtd_status;
 554         int                     i;
 555         struct langwell_dqh     *dqh;
 556         struct langwell_udc     *dev;
 557
 558         dev = ep->dev;
 559         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 560
 561         i = ep->ep_num * 2 + is_in(ep);
 562         dqh = &dev->ep_dqh[i];
 563
 564         if (ep->ep_num)
 565                 dev_vdbg(&dev->pdev->dev, "%s\n", ep->name);
 566         else
 567                 /* ep0 */
 568                 dev_vdbg(&dev->pdev->dev, "%s-%s\n", ep->name, DIR_STRING(ep));
 569
 570         dev_vdbg(&dev->pdev->dev, "ep_dqh[%d] addr: 0x%p\n",
 571                         i, &(dev->ep_dqh[i]));
 572
 573         bit_mask = is_in(ep) ?
 574                 (1 << (ep->ep_num + 16)) : (1 << (ep->ep_num));
 575
 576         dev_vdbg(&dev->pdev->dev, "bit_mask = 0x%08x\n", bit_mask);
 577
 578         /* check if the pipe is empty */
 579         if (!(list_empty(&ep->queue))) {
 580                 /* add dTD to the end of linked list */
 581                 struct langwell_request *lastreq;
 582                 lastreq = list_entry(ep->queue.prev,
 583                                 struct langwell_request, queue);
 584
 585                 lastreq->tail->dtd_next =
 586                         cpu_to_le32(req->head->dtd_dma & DTD_NEXT_MASK);
 587
 588                 /* read prime bit, if 1 goto out */
 589                 if (readl(&dev->op_regs->endptprime) & bit_mask)
 590                         goto out;
 591
 592                 do {
 593                         /* set ATDTW bit in USBCMD */
 594                         usbcmd = readl(&dev->op_regs->usbcmd);
 595                         writel(usbcmd | CMD_ATDTW, &dev->op_regs->usbcmd);
 596
 597                         /* read correct status bit */
 598                         endptstat = readl(&dev->op_regs->endptstat) & bit_mask;
 599
 600                 } while (!(readl(&dev->op_regs->usbcmd) & CMD_ATDTW));
 601
 602                 /* write ATDTW bit to 0 */
 603                 usbcmd = readl(&dev->op_regs->usbcmd);
 604                 writel(usbcmd & ~CMD_ATDTW, &dev->op_regs->usbcmd);
 605
 606                 if (endptstat)
 607                         goto out;
 608         }
 609
 610         /* write dQH next pointer and terminate bit to 0 */
 611         dtd_dma = req->head->dtd_dma & DTD_NEXT_MASK;
 612         dqh->dtd_next = cpu_to_le32(dtd_dma);
 613
 614         /* clear active and halt bit */
 615         dtd_status = (u8) ~(DTD_STS_ACTIVE | DTD_STS_HALTED);
 616         dqh->dtd_status &= dtd_status;
 617         dev_vdbg(&dev->pdev->dev, "dqh->dtd_status = 0x%x\n", dqh->dtd_status);
 618
 619         /* ensure that updates to the dQH will occur before priming */
 620         wmb();
 621
 622         /* write 1 to endptprime register to PRIME endpoint */
 623         bit_mask = is_in(ep) ? (1 << (ep->ep_num + 16)) : (1 << ep->ep_num);
 624         dev_vdbg(&dev->pdev->dev, "endprime bit_mask = 0x%08x\n", bit_mask);
 625         writel(bit_mask, &dev->op_regs->endptprime);
 626 out:
 627         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 628         return 0;
 629 }
 630
 631
 632 /* fill in the dTD structure to build a transfer descriptor */
 633 static struct langwell_dtd *build_dtd(struct langwell_request *req,
 634                 unsigned *length, dma_addr_t *dma, int *is_last)
 635 {
 636         u32                      buf_ptr;
 637         struct langwell_dtd     *dtd;
 638         struct langwell_udc     *dev;
 639         int                     i;
 640
 641         dev = req->ep->dev;
 642         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 643
 644         /* the maximum transfer length, up to 16k bytes */
 645         *length = min(req->req.length - req->req.actual,
 646                         (unsigned)DTD_MAX_TRANSFER_LENGTH);
 647
 648         /* create dTD dma_pool resource */
 649         dtd = dma_pool_alloc(dev->dtd_pool, GFP_KERNEL, dma);
 650         if (dtd == NULL)
 651                 return dtd;
 652         dtd->dtd_dma = *dma;
 653
 654         /* initialize buffer page pointers */
 655         buf_ptr = (u32)(req->req.dma + req->req.actual);
 656         for (i = 0; i < 5; i++)
 657                 dtd->dtd_buf[i] = cpu_to_le32(buf_ptr + i * PAGE_SIZE);
 658
 659         req->req.actual += *length;
 660
 661         /* fill in total bytes with transfer size */
 662         dtd->dtd_total = cpu_to_le16(*length);
 663         dev_vdbg(&dev->pdev->dev, "dtd->dtd_total = %d\n", dtd->dtd_total);
 664
 665         /* set is_last flag if req->req.zero is set or not */
 666         if (req->req.zero) {
 667                 if (*length == 0 || (*length % req->ep->ep.maxpacket) != 0)
 668                         *is_last = 1;
 669                 else
 670                         *is_last = 0;
 671         } else if (req->req.length == req->req.actual) {
 672                 *is_last = 1;
 673         } else
 674                 *is_last = 0;
 675
 676         if (*is_last == 0)
 677                 dev_vdbg(&dev->pdev->dev, "multi-dtd request!\n");
 678
 679         /* set interrupt on complete bit for the last dTD */
 680         if (*is_last && !req->req.no_interrupt)
 681                 dtd->dtd_ioc = 1;
 682
 683         /* set multiplier override 0 for non-ISO and non-TX endpoint */
 684         dtd->dtd_multo = 0;
 685
 686         /* set the active bit of status field to 1 */
 687         dtd->dtd_status = DTD_STS_ACTIVE;
 688         dev_vdbg(&dev->pdev->dev, "dtd->dtd_status = 0x%02x\n",
 689                         dtd->dtd_status);
 690
 691         dev_vdbg(&dev->pdev->dev, "length = %d, dma addr= 0x%08x\n",
 692                         *length, (int)*dma);
 693         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 694         return dtd;
 695 }
 696
 697
 698 /* generate dTD linked list for a request */
 699 static int req_to_dtd(struct langwell_request *req)
 700 {
 701         unsigned                count;
 702         int                     is_last, is_first = 1;
 703         struct langwell_dtd     *dtd, *last_dtd = NULL;
 704         struct langwell_udc     *dev;
 705         dma_addr_t              dma;
 706
 707         dev = req->ep->dev;
 708         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 709         do {
 710                 dtd = build_dtd(req, &count, &dma, &is_last);
 711                 if (dtd == NULL)
 712                         return -ENOMEM;
 713
 714                 if (is_first) {
 715                         is_first = 0;
 716                         req->head = dtd;
 717                 } else {
 718                         last_dtd->dtd_next = cpu_to_le32(dma);
 719                         last_dtd->next_dtd_virt = dtd;
 720                 }
 721                 last_dtd = dtd;
 722                 req->dtd_count++;
 723         } while (!is_last);
 724
 725         /* set terminate bit to 1 for the last dTD */
 726         dtd->dtd_next = DTD_TERM;
 727
 728         req->tail = dtd;
 729
 730         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 731         return 0;
 732 }
 733
 734 /*-------------------------------------------------------------------------*/
 735
 736 /* queue (submits) an I/O requests to an endpoint */
 737 static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
 738                 gfp_t gfp_flags)
 739 {
 740         struct langwell_request *req;
 741         struct langwell_ep      *ep;
 742         struct langwell_udc     *dev;
 743         unsigned long           flags;
 744         int                     is_iso = 0;
 745         int                     ret;
 746
 747         /* always require a cpu-view buffer */
 748         req = container_of(_req, struct langwell_request, req);
 749         ep = container_of(_ep, struct langwell_ep, ep);
 750
 751         if (!_req || !_req->complete || !_req->buf
 752                         || !list_empty(&req->queue)) {
 753                 return -EINVAL;
 754         }
 755
 756         if (unlikely(!_ep || !ep->desc))
 757                 return -EINVAL;
 758
 759         dev = ep->dev;
 760         req->ep = ep;
 761         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 762
 763         if (usb_endpoint_xfer_isoc(ep->desc)) {
 764                 if (req->req.length > ep->ep.maxpacket)
 765                         return -EMSGSIZE;
 766                 is_iso = 1;
 767         }
 768
 769         if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
 770                 return -ESHUTDOWN;
 771
 772         /* set up dma mapping */
 773         ret = usb_gadget_map_request(&dev->gadget, &req->req, is_in(ep));
 774         if (ret)
 775                 return ret;
 776
 777         dev_dbg(&dev->pdev->dev,
 778                         "%s queue req %p, len %u, buf %p, dma 0x%08x\n",
 779                         _ep->name,
 780                         _req, _req->length, _req->buf, (int)_req->dma);
 781
 782         _req->status = -EINPROGRESS;
 783         _req->actual = 0;
 784         req->dtd_count = 0;
 785
 786         spin_lock_irqsave(&dev->lock, flags);
 787
 788         /* build and put dTDs to endpoint queue */
 789         if (!req_to_dtd(req)) {
 790                 queue_dtd(ep, req);
 791         } else {
 792                 spin_unlock_irqrestore(&dev->lock, flags);
 793                 return -ENOMEM;
 794         }
 795
 796         /* update ep0 state */
 797         if (ep->ep_num == 0)
 798                 dev->ep0_state = DATA_STATE_XMIT;
 799
 800         if (likely(req != NULL)) {
 801                 list_add_tail(&req->queue, &ep->queue);
 802                 dev_vdbg(&dev->pdev->dev, "list_add_tail()\n");
 803         }
 804
 805         spin_unlock_irqrestore(&dev->lock, flags);
 806
 807         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 808         return 0;
 809 }
 810
 811
 812 /* dequeue (cancels, unlinks) an I/O request from an endpoint */
 813 static int langwell_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 814 {
 815         struct langwell_ep      *ep;
 816         struct langwell_udc     *dev;
 817         struct langwell_request *req;
 818         unsigned long           flags;
 819         int                     stopped, ep_num, retval = 0;
 820         u32                     endptctrl;
 821
 822         ep = container_of(_ep, struct langwell_ep, ep);
 823         dev = ep->dev;
 824         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 825
 826         if (!_ep || !ep->desc || !_req)
 827                 return -EINVAL;
 828
 829         if (!dev->driver)
 830                 return -ESHUTDOWN;
 831
 832         spin_lock_irqsave(&dev->lock, flags);
 833         stopped = ep->stopped;
 834
 835         /* quiesce dma while we patch the queue */
 836         ep->stopped = 1;
 837         ep_num = ep->ep_num;
 838
 839         /* disable endpoint control register */
 840         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
 841         if (is_in(ep))
 842                 endptctrl &= ~EPCTRL_TXE;
 843         else
 844                 endptctrl &= ~EPCTRL_RXE;
 845         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 846
 847         /* make sure it's still queued on this endpoint */
 848         list_for_each_entry(req, &ep->queue, queue) {
 849                 if (&req->req == _req)
 850                         break;
 851         }
 852
 853         if (&req->req != _req) {
 854                 retval = -EINVAL;
 855                 goto done;
 856         }
 857
 858         /* queue head may be partially complete. */
 859         if (ep->queue.next == &req->queue) {
 860                 dev_dbg(&dev->pdev->dev, "unlink (%s) dma\n", _ep->name);
 861                 _req->status = -ECONNRESET;
 862                 langwell_ep_fifo_flush(&ep->ep);
 863
 864                 /* not the last request in endpoint queue */
 865                 if (likely(ep->queue.next == &req->queue)) {
 866                         struct langwell_dqh     *dqh;
 867                         struct langwell_request *next_req;
 868
 869                         dqh = ep->dqh;
 870                         next_req = list_entry(req->queue.next,
 871                                         struct langwell_request, queue);
 872
 873                         /* point the dQH to the first dTD of next request */
 874                         writel((u32) next_req->head, &dqh->dqh_current);
 875                 }
 876         } else {
 877                 struct langwell_request *prev_req;
 878
 879                 prev_req = list_entry(req->queue.prev,
 880                                 struct langwell_request, queue);
 881                 writel(readl(&req->tail->dtd_next),
 882                                 &prev_req->tail->dtd_next);
 883         }
 884
 885         done(ep, req, -ECONNRESET);
 886
 887 done:
 888         /* enable endpoint again */
 889         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
 890         if (is_in(ep))
 891                 endptctrl |= EPCTRL_TXE;
 892         else
 893                 endptctrl |= EPCTRL_RXE;
 894         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 895
 896         ep->stopped = stopped;
 897         spin_unlock_irqrestore(&dev->lock, flags);
 898
 899         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 900         return retval;
 901 }
 902
 903
 904 /*-------------------------------------------------------------------------*/
 905
 906 /* endpoint set/clear halt */
 907 static void ep_set_halt(struct langwell_ep *ep, int value)
 908 {
 909         u32                     endptctrl = 0;
 910         int                     ep_num;
 911         struct langwell_udc     *dev = ep->dev;
 912         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 913
 914         ep_num = ep->ep_num;
 915         endptctrl = readl(&dev->op_regs->endptctrl[ep_num]);
 916
 917         /* value: 1 - set halt, 0 - clear halt */
 918         if (value) {
 919                 /* set the stall bit */
 920                 if (is_in(ep))
 921                         endptctrl |= EPCTRL_TXS;
 922                 else
 923                         endptctrl |= EPCTRL_RXS;
 924         } else {
 925                 /* clear the stall bit and reset data toggle */
 926                 if (is_in(ep)) {
 927                         endptctrl &= ~EPCTRL_TXS;
 928                         endptctrl |= EPCTRL_TXR;
 929                 } else {
 930                         endptctrl &= ~EPCTRL_RXS;
 931                         endptctrl |= EPCTRL_RXR;
 932                 }
 933         }
 934
 935         writel(endptctrl, &dev->op_regs->endptctrl[ep_num]);
 936
 937         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 938 }
 939
 940
 941 /* set the endpoint halt feature */
 942 static int langwell_ep_set_halt(struct usb_ep *_ep, int value)
 943 {
 944         struct langwell_ep      *ep;
 945         struct langwell_udc     *dev;
 946         unsigned long           flags;
 947         int                     retval = 0;
 948
 949         ep = container_of(_ep, struct langwell_ep, ep);
 950         dev = ep->dev;
 951
 952         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 953
 954         if (!_ep || !ep->desc)
 955                 return -EINVAL;
 956
 957         if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
 958                 return -ESHUTDOWN;
 959
 960         if (usb_endpoint_xfer_isoc(ep->desc))
 961                 return  -EOPNOTSUPP;
 962
 963         spin_lock_irqsave(&dev->lock, flags);
 964
 965         /*
 966          * attempt to halt IN ep will fail if any transfer requests
 967          * are still queue
 968          */
 969         if (!list_empty(&ep->queue) && is_in(ep) && value) {
 970                 /* IN endpoint FIFO holds bytes */
 971                 dev_dbg(&dev->pdev->dev, "%s FIFO holds bytes\n", _ep->name);
 972                 retval = -EAGAIN;
 973                 goto done;
 974         }
 975
 976         /* endpoint set/clear halt */
 977         if (ep->ep_num) {
 978                 ep_set_halt(ep, value);
 979         } else { /* endpoint 0 */
 980                 dev->ep0_state = WAIT_FOR_SETUP;
 981                 dev->ep0_dir = USB_DIR_OUT;
 982         }
 983 done:
 984         spin_unlock_irqrestore(&dev->lock, flags);
 985         dev_dbg(&dev->pdev->dev, "%s %s halt\n",
 986                         _ep->name, value ? "set" : "clear");
 987         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
 988         return retval;
 989 }
 990
 991
 992 /* set the halt feature and ignores clear requests */
 993 static int langwell_ep_set_wedge(struct usb_ep *_ep)
 994 {
 995         struct langwell_ep      *ep;
 996         struct langwell_udc     *dev;
 997
 998         ep = container_of(_ep, struct langwell_ep, ep);
 999         dev = ep->dev;
1000
1001         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1002
1003         if (!_ep || !ep->desc)
1004                 return -EINVAL;
1005
1006         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1007         return usb_ep_set_halt(_ep);
1008 }
1009
1010
1011 /* flush contents of a fifo */
1012 static void langwell_ep_fifo_flush(struct usb_ep *_ep)
1013 {
1014         struct langwell_ep      *ep;
1015         struct langwell_udc     *dev;
1016         u32                     flush_bit;
1017         unsigned long           timeout;
1018
1019         ep = container_of(_ep, struct langwell_ep, ep);
1020         dev = ep->dev;
1021
1022         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1023
1024         if (!_ep || !ep->desc) {
1025                 dev_vdbg(&dev->pdev->dev, "ep or ep->desc is NULL\n");
1026                 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1027                 return;
1028         }
1029
1030         dev_vdbg(&dev->pdev->dev, "%s-%s fifo flush\n",
1031                         _ep->name, DIR_STRING(ep));
1032
1033         /* flush endpoint buffer */
1034         if (ep->ep_num == 0)
1035                 flush_bit = (1 << 16) | 1;
1036         else if (is_in(ep))
1037                 flush_bit = 1 << (ep->ep_num + 16);     /* TX */
1038         else
1039                 flush_bit = 1 << ep->ep_num;            /* RX */
1040
1041         /* wait until flush complete */
1042         timeout = jiffies + FLUSH_TIMEOUT;
1043         do {
1044                 writel(flush_bit, &dev->op_regs->endptflush);
1045                 while (readl(&dev->op_regs->endptflush)) {
1046                         if (time_after(jiffies, timeout)) {
1047                                 dev_err(&dev->pdev->dev, "ep flush timeout\n");
1048                                 goto done;
1049                         }
1050                         cpu_relax();
1051                 }
1052         } while (readl(&dev->op_regs->endptstat) & flush_bit);
1053 done:
1054         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1055 }
1056
1057
1058 /* endpoints operations structure */
1059 static const struct usb_ep_ops langwell_ep_ops = {
1060
1061         /* configure endpoint, making it usable */
1062         .enable         = langwell_ep_enable,
1063
1064         /* endpoint is no longer usable */
1065         .disable        = langwell_ep_disable,
1066
1067         /* allocate a request object to use with this endpoint */
1068         .alloc_request  = langwell_alloc_request,
1069
1070         /* free a request object */
1071         .free_request   = langwell_free_request,
1072
1073         /* queue (submits) an I/O requests to an endpoint */
1074         .queue          = langwell_ep_queue,
1075
1076         /* dequeue (cancels, unlinks) an I/O request from an endpoint */
1077         .dequeue        = langwell_ep_dequeue,
1078
1079         /* set the endpoint halt feature */
1080         .set_halt       = langwell_ep_set_halt,
1081
1082         /* set the halt feature and ignores clear requests */
1083         .set_wedge      = langwell_ep_set_wedge,
1084
1085         /* flush contents of a fifo */
1086         .fifo_flush     = langwell_ep_fifo_flush,
1087 };
1088
1089
1090 /*-------------------------------------------------------------------------*/
1091
1092 /* device controller usb_gadget_ops structure */
1093
1094 /* returns the current frame number */
1095 static int langwell_get_frame(struct usb_gadget *_gadget)
1096 {
1097         struct langwell_udc     *dev;
1098         u16                     retval;
1099
1100         if (!_gadget)
1101                 return -ENODEV;
1102
1103         dev = container_of(_gadget, struct langwell_udc, gadget);
1104         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1105
1106         retval = readl(&dev->op_regs->frindex) & FRINDEX_MASK;
1107
1108         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1109         return retval;
1110 }
1111
1112
1113 /* enter or exit PHY low power state */
1114 static void langwell_phy_low_power(struct langwell_udc *dev, bool flag)
1115 {
1116         u32             devlc;
1117         u8              devlc_byte2;
1118         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1119
1120         devlc = readl(&dev->op_regs->devlc);
1121         dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
1122
1123         if (flag)
1124                 devlc |= LPM_PHCD;
1125         else
1126                 devlc &= ~LPM_PHCD;
1127
1128         /* FIXME: workaround for Langwell A1/A2/A3 sighting */
1129         devlc_byte2 = (devlc >> 16) & 0xff;
1130         writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
1131
1132         devlc = readl(&dev->op_regs->devlc);
1133         dev_vdbg(&dev->pdev->dev,
1134                         "%s PHY low power suspend, devlc = 0x%08x\n",
1135                         flag ? "enter" : "exit", devlc);
1136 }
1137
1138
1139 /* tries to wake up the host connected to this gadget */
1140 static int langwell_wakeup(struct usb_gadget *_gadget)
1141 {
1142         struct langwell_udc     *dev;
1143         u32                     portsc1;
1144         unsigned long           flags;
1145
1146         if (!_gadget)
1147                 return 0;
1148
1149         dev = container_of(_gadget, struct langwell_udc, gadget);
1150         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1151
1152         /* remote wakeup feature not enabled by host */
1153         if (!dev->remote_wakeup) {
1154                 dev_info(&dev->pdev->dev, "remote wakeup is disabled\n");
1155                 return -ENOTSUPP;
1156         }
1157
1158         spin_lock_irqsave(&dev->lock, flags);
1159
1160         portsc1 = readl(&dev->op_regs->portsc1);
1161         if (!(portsc1 & PORTS_SUSP)) {
1162                 spin_unlock_irqrestore(&dev->lock, flags);
1163                 return 0;
1164         }
1165
1166         /* LPM L1 to L0 or legacy remote wakeup */
1167         if (dev->lpm && dev->lpm_state == LPM_L1)
1168                 dev_info(&dev->pdev->dev, "LPM L1 to L0 remote wakeup\n");
1169         else
1170                 dev_info(&dev->pdev->dev, "device remote wakeup\n");
1171
1172         /* exit PHY low power suspend */
1173         if (dev->pdev->device != 0x0829)
1174                 langwell_phy_low_power(dev, 0);
1175
1176         /* force port resume */
1177         portsc1 |= PORTS_FPR;
1178         writel(portsc1, &dev->op_regs->portsc1);
1179
1180         spin_unlock_irqrestore(&dev->lock, flags);
1181
1182         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1183         return 0;
1184 }
1185
1186
1187 /* notify controller that VBUS is powered or not */
1188 static int langwell_vbus_session(struct usb_gadget *_gadget, int is_active)
1189 {
1190         struct langwell_udc     *dev;
1191         unsigned long           flags;
1192         u32                     usbcmd;
1193
1194         if (!_gadget)
1195                 return -ENODEV;
1196
1197         dev = container_of(_gadget, struct langwell_udc, gadget);
1198         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1199
1200         spin_lock_irqsave(&dev->lock, flags);
1201         dev_vdbg(&dev->pdev->dev, "VBUS status: %s\n",
1202                         is_active ? "on" : "off");
1203
1204         dev->vbus_active = (is_active != 0);
1205         if (dev->driver && dev->softconnected && dev->vbus_active) {
1206                 usbcmd = readl(&dev->op_regs->usbcmd);
1207                 usbcmd |= CMD_RUNSTOP;
1208                 writel(usbcmd, &dev->op_regs->usbcmd);
1209         } else {
1210                 usbcmd = readl(&dev->op_regs->usbcmd);
1211                 usbcmd &= ~CMD_RUNSTOP;
1212                 writel(usbcmd, &dev->op_regs->usbcmd);
1213         }
1214
1215         spin_unlock_irqrestore(&dev->lock, flags);
1216
1217         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1218         return 0;
1219 }
1220
1221
1222 /* constrain controller's VBUS power usage */
1223 static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
1224 {
1225         struct langwell_udc     *dev;
1226
1227         if (!_gadget)
1228                 return -ENODEV;
1229
1230         dev = container_of(_gadget, struct langwell_udc, gadget);
1231         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1232
1233         if (dev->transceiver) {
1234                 dev_vdbg(&dev->pdev->dev, "usb_phy_set_power\n");
1235                 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1236                 return usb_phy_set_power(dev->transceiver, mA);
1237         }
1238
1239         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1240         return -ENOTSUPP;
1241 }
1242
1243
1244 /* D+ pullup, software-controlled connect/disconnect to USB host */
1245 static int langwell_pullup(struct usb_gadget *_gadget, int is_on)
1246 {
1247         struct langwell_udc     *dev;
1248         u32                     usbcmd;
1249         unsigned long           flags;
1250
1251         if (!_gadget)
1252                 return -ENODEV;
1253
1254         dev = container_of(_gadget, struct langwell_udc, gadget);
1255
1256         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1257
1258         spin_lock_irqsave(&dev->lock, flags);
1259         dev->softconnected = (is_on != 0);
1260
1261         if (dev->driver && dev->softconnected && dev->vbus_active) {
1262                 usbcmd = readl(&dev->op_regs->usbcmd);
1263                 usbcmd |= CMD_RUNSTOP;
1264                 writel(usbcmd, &dev->op_regs->usbcmd);
1265         } else {
1266                 usbcmd = readl(&dev->op_regs->usbcmd);
1267                 usbcmd &= ~CMD_RUNSTOP;
1268                 writel(usbcmd, &dev->op_regs->usbcmd);
1269         }
1270         spin_unlock_irqrestore(&dev->lock, flags);
1271
1272         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1273         return 0;
1274 }
1275
1276 static int langwell_start(struct usb_gadget *g,
1277                 struct usb_gadget_driver *driver);
1278
1279 static int langwell_stop(struct usb_gadget *g,
1280                 struct usb_gadget_driver *driver);
1281
1282 /* device controller usb_gadget_ops structure */
1283 static const struct usb_gadget_ops langwell_ops = {
1284
1285         /* returns the current frame number */
1286         .get_frame      = langwell_get_frame,
1287
1288         /* tries to wake up the host connected to this gadget */
1289         .wakeup         = langwell_wakeup,
1290
1291         /* set the device selfpowered feature, always selfpowered */
1292         /* .set_selfpowered = langwell_set_selfpowered, */
1293
1294         /* notify controller that VBUS is powered or not */
1295         .vbus_session   = langwell_vbus_session,
1296
1297         /* constrain controller's VBUS power usage */
1298         .vbus_draw      = langwell_vbus_draw,
1299
1300         /* D+ pullup, software-controlled connect/disconnect to USB host */
1301         .pullup         = langwell_pullup,
1302
1303         .udc_start      = langwell_start,
1304         .udc_stop       = langwell_stop,
1305 };
1306
1307
1308 /*-------------------------------------------------------------------------*/
1309
1310 /* device controller operations */
1311
1312 /* reset device controller */
1313 static int langwell_udc_reset(struct langwell_udc *dev)
1314 {
1315         u32             usbcmd, usbmode, devlc, endpointlistaddr;
1316         u8              devlc_byte0, devlc_byte2;
1317         unsigned long   timeout;
1318
1319         if (!dev)
1320                 return -EINVAL;
1321
1322         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1323
1324         /* set controller to stop state */
1325         usbcmd = readl(&dev->op_regs->usbcmd);
1326         usbcmd &= ~CMD_RUNSTOP;
1327         writel(usbcmd, &dev->op_regs->usbcmd);
1328
1329         /* reset device controller */
1330         usbcmd = readl(&dev->op_regs->usbcmd);
1331         usbcmd |= CMD_RST;
1332         writel(usbcmd, &dev->op_regs->usbcmd);
1333
1334         /* wait for reset to complete */
1335         timeout = jiffies + RESET_TIMEOUT;
1336         while (readl(&dev->op_regs->usbcmd) & CMD_RST) {
1337                 if (time_after(jiffies, timeout)) {
1338                         dev_err(&dev->pdev->dev, "device reset timeout\n");
1339                         return -ETIMEDOUT;
1340                 }
1341                 cpu_relax();
1342         }
1343
1344         /* set controller to device mode */
1345         usbmode = readl(&dev->op_regs->usbmode);
1346         usbmode |= MODE_DEVICE;
1347
1348         /* turn setup lockout off, require setup tripwire in usbcmd */
1349         usbmode |= MODE_SLOM;
1350
1351         writel(usbmode, &dev->op_regs->usbmode);
1352         usbmode = readl(&dev->op_regs->usbmode);
1353         dev_vdbg(&dev->pdev->dev, "usbmode=0x%08x\n", usbmode);
1354
1355         /* Write-Clear setup status */
1356         writel(0, &dev->op_regs->usbsts);
1357
1358         /* if support USB LPM, ACK all LPM token */
1359         if (dev->lpm) {
1360                 devlc = readl(&dev->op_regs->devlc);
1361                 dev_vdbg(&dev->pdev->dev, "devlc = 0x%08x\n", devlc);
1362                 /* FIXME: workaround for Langwell A1/A2/A3 sighting */
1363                 devlc &= ~LPM_STL;      /* don't STALL LPM token */
1364                 devlc &= ~LPM_NYT_ACK;  /* ACK LPM token */
1365                 devlc_byte0 = devlc & 0xff;
1366                 devlc_byte2 = (devlc >> 16) & 0xff;
1367                 writeb(devlc_byte0, (u8 *)&dev->op_regs->devlc);
1368                 writeb(devlc_byte2, (u8 *)&dev->op_regs->devlc + 2);
1369                 devlc = readl(&dev->op_regs->devlc);
1370                 dev_vdbg(&dev->pdev->dev,
1371                                 "ACK LPM token, devlc = 0x%08x\n", devlc);
1372         }
1373
1374         /* fill endpointlistaddr register */
1375         endpointlistaddr = dev->ep_dqh_dma;
1376         endpointlistaddr &= ENDPOINTLISTADDR_MASK;
1377         writel(endpointlistaddr, &dev->op_regs->endpointlistaddr);
1378
1379         dev_vdbg(&dev->pdev->dev,
1380                 "dQH base (vir: %p, phy: 0x%08x), endpointlistaddr=0x%08x\n",
1381                 dev->ep_dqh, endpointlistaddr,
1382                 readl(&dev->op_regs->endpointlistaddr));
1383         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1384         return 0;
1385 }
1386
1387
1388 /* reinitialize device controller endpoints */
1389 static int eps_reinit(struct langwell_udc *dev)
1390 {
1391         struct langwell_ep      *ep;
1392         char                    name[14];
1393         int                     i;
1394
1395         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1396
1397         /* initialize ep0 */
1398         ep = &dev->ep[0];
1399         ep->dev = dev;
1400         strncpy(ep->name, "ep0", sizeof(ep->name));
1401         ep->ep.name = ep->name;
1402         ep->ep.ops = &langwell_ep_ops;
1403         ep->stopped = 0;
1404         ep->ep.maxpacket = EP0_MAX_PKT_SIZE;
1405         ep->ep_num = 0;
1406         ep->desc = &langwell_ep0_desc;
1407         INIT_LIST_HEAD(&ep->queue);
1408
1409         ep->ep_type = USB_ENDPOINT_XFER_CONTROL;
1410
1411         /* initialize other endpoints */
1412         for (i = 2; i < dev->ep_max; i++) {
1413                 ep = &dev->ep[i];
1414                 if (i % 2)
1415                         snprintf(name, sizeof(name), "ep%din", i / 2);
1416                 else
1417                         snprintf(name, sizeof(name), "ep%dout", i / 2);
1418                 ep->dev = dev;
1419                 strncpy(ep->name, name, sizeof(ep->name));
1420                 ep->ep.name = ep->name;
1421
1422                 ep->ep.ops = &langwell_ep_ops;
1423                 ep->stopped = 0;
1424                 ep->ep.maxpacket = (unsigned short) ~0;
1425                 ep->ep_num = i / 2;
1426
1427                 INIT_LIST_HEAD(&ep->queue);
1428                 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
1429         }
1430
1431         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1432         return 0;
1433 }
1434
1435
1436 /* enable interrupt and set controller to run state */
1437 static void langwell_udc_start(struct langwell_udc *dev)
1438 {
1439         u32     usbintr, usbcmd;
1440         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1441
1442         /* enable interrupts */
1443         usbintr = INTR_ULPIE    /* ULPI */
1444                 | INTR_SLE      /* suspend */
1445                 /* | INTR_SRE   SOF received */
1446                 | INTR_URE      /* USB reset */
1447                 | INTR_AAE      /* async advance */
1448                 | INTR_SEE      /* system error */
1449                 | INTR_FRE      /* frame list rollover */
1450                 | INTR_PCE      /* port change detect */
1451                 | INTR_UEE      /* USB error interrupt */
1452                 | INTR_UE;      /* USB interrupt */
1453         writel(usbintr, &dev->op_regs->usbintr);
1454
1455         /* clear stopped bit */
1456         dev->stopped = 0;
1457
1458         /* set controller to run */
1459         usbcmd = readl(&dev->op_regs->usbcmd);
1460         usbcmd |= CMD_RUNSTOP;
1461         writel(usbcmd, &dev->op_regs->usbcmd);
1462
1463         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1464 }
1465
1466
1467 /* disable interrupt and set controller to stop state */
1468 static void langwell_udc_stop(struct langwell_udc *dev)
1469 {
1470         u32     usbcmd;
1471
1472         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1473
1474         /* disable all interrupts */
1475         writel(0, &dev->op_regs->usbintr);
1476
1477         /* set stopped bit */
1478         dev->stopped = 1;
1479
1480         /* set controller to stop state */
1481         usbcmd = readl(&dev->op_regs->usbcmd);
1482         usbcmd &= ~CMD_RUNSTOP;
1483         writel(usbcmd, &dev->op_regs->usbcmd);
1484
1485         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1486 }
1487
1488
1489 /* stop all USB activities */
1490 static void stop_activity(struct langwell_udc *dev)
1491 {
1492         struct langwell_ep      *ep;
1493         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1494
1495         nuke(&dev->ep[0], -ESHUTDOWN);
1496
1497         list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1498                 nuke(ep, -ESHUTDOWN);
1499         }
1500
1501         /* report disconnect; the driver is already quiesced */
1502         if (dev->driver) {
1503                 spin_unlock(&dev->lock);
1504                 dev->driver->disconnect(&dev->gadget);
1505                 spin_lock(&dev->lock);
1506         }
1507
1508         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1509 }
1510
1511
1512 /*-------------------------------------------------------------------------*/
1513
1514 /* device "function" sysfs attribute file */
1515 static ssize_t show_function(struct device *_dev,
1516                 struct device_attribute *attr, char *buf)
1517 {
1518         struct langwell_udc     *dev = dev_get_drvdata(_dev);
1519
1520         if (!dev->driver || !dev->driver->function
1521                         || strlen(dev->driver->function) > PAGE_SIZE)
1522                 return 0;
1523
1524         return scnprintf(buf, PAGE_SIZE, "%s\n", dev->driver->function);
1525 }
1526 static DEVICE_ATTR(function, S_IRUGO, show_function, NULL);
1527
1528
1529 static inline enum usb_device_speed lpm_device_speed(u32 reg)
1530 {
1531         switch (LPM_PSPD(reg)) {
1532         case LPM_SPEED_HIGH:
1533                 return USB_SPEED_HIGH;
1534         case LPM_SPEED_FULL:
1535                 return USB_SPEED_FULL;
1536         case LPM_SPEED_LOW:
1537                 return USB_SPEED_LOW;
1538         default:
1539                 return USB_SPEED_UNKNOWN;
1540         }
1541 }
1542
1543 /* device "langwell_udc" sysfs attribute file */
1544 static ssize_t show_langwell_udc(struct device *_dev,
1545                 struct device_attribute *attr, char *buf)
1546 {
1547         struct langwell_udc     *dev = dev_get_drvdata(_dev);
1548         struct langwell_request *req;
1549         struct langwell_ep      *ep = NULL;
1550         char                    *next;
1551         unsigned                size;
1552         unsigned                t;
1553         unsigned                i;
1554         unsigned long           flags;
1555         u32                     tmp_reg;
1556
1557         next = buf;
1558         size = PAGE_SIZE;
1559         spin_lock_irqsave(&dev->lock, flags);
1560
1561         /* driver basic information */
1562         t = scnprintf(next, size,
1563                         DRIVER_DESC "\n"
1564                         "%s version: %s\n"
1565                         "Gadget driver: %s\n\n",
1566                         driver_name, DRIVER_VERSION,
1567                         dev->driver ? dev->driver->driver.name : "(none)");
1568         size -= t;
1569         next += t;
1570
1571         /* device registers */
1572         tmp_reg = readl(&dev->op_regs->usbcmd);
1573         t = scnprintf(next, size,
1574                         "USBCMD reg:\n"
1575                         "SetupTW: %d\n"
1576                         "Run/Stop: %s\n\n",
1577                         (tmp_reg & CMD_SUTW) ? 1 : 0,
1578                         (tmp_reg & CMD_RUNSTOP) ? "Run" : "Stop");
1579         size -= t;
1580         next += t;
1581
1582         tmp_reg = readl(&dev->op_regs->usbsts);
1583         t = scnprintf(next, size,
1584                         "USB Status Reg:\n"
1585                         "Device Suspend: %d\n"
1586                         "Reset Received: %d\n"
1587                         "System Error: %s\n"
1588                         "USB Error Interrupt: %s\n\n",
1589                         (tmp_reg & STS_SLI) ? 1 : 0,
1590                         (tmp_reg & STS_URI) ? 1 : 0,
1591                         (tmp_reg & STS_SEI) ? "Error" : "No error",
1592                         (tmp_reg & STS_UEI) ? "Error detected" : "No error");
1593         size -= t;
1594         next += t;
1595
1596         tmp_reg = readl(&dev->op_regs->usbintr);
1597         t = scnprintf(next, size,
1598                         "USB Intrrupt Enable Reg:\n"
1599                         "Sleep Enable: %d\n"
1600                         "SOF Received Enable: %d\n"
1601                         "Reset Enable: %d\n"
1602                         "System Error Enable: %d\n"
1603                         "Port Change Dectected Enable: %d\n"
1604                         "USB Error Intr Enable: %d\n"
1605                         "USB Intr Enable: %d\n\n",
1606                         (tmp_reg & INTR_SLE) ? 1 : 0,
1607                         (tmp_reg & INTR_SRE) ? 1 : 0,
1608                         (tmp_reg & INTR_URE) ? 1 : 0,
1609                         (tmp_reg & INTR_SEE) ? 1 : 0,
1610                         (tmp_reg & INTR_PCE) ? 1 : 0,
1611                         (tmp_reg & INTR_UEE) ? 1 : 0,
1612                         (tmp_reg & INTR_UE) ? 1 : 0);
1613         size -= t;
1614         next += t;
1615
1616         tmp_reg = readl(&dev->op_regs->frindex);
1617         t = scnprintf(next, size,
1618                         "USB Frame Index Reg:\n"
1619                         "Frame Number is 0x%08x\n\n",
1620                         (tmp_reg & FRINDEX_MASK));
1621         size -= t;
1622         next += t;
1623
1624         tmp_reg = readl(&dev->op_regs->deviceaddr);
1625         t = scnprintf(next, size,
1626                         "USB Device Address Reg:\n"
1627                         "Device Addr is 0x%x\n\n",
1628                         USBADR(tmp_reg));
1629         size -= t;
1630         next += t;
1631
1632         tmp_reg = readl(&dev->op_regs->endpointlistaddr);
1633         t = scnprintf(next, size,
1634                         "USB Endpoint List Address Reg:\n"
1635                         "Endpoint List Pointer is 0x%x\n\n",
1636                         EPBASE(tmp_reg));
1637         size -= t;
1638         next += t;
1639
1640         tmp_reg = readl(&dev->op_regs->portsc1);
1641         t = scnprintf(next, size,
1642                 "USB Port Status & Control Reg:\n"
1643                 "Port Reset: %s\n"
1644                 "Port Suspend Mode: %s\n"
1645                 "Over-current Change: %s\n"
1646                 "Port Enable/Disable Change: %s\n"
1647                 "Port Enabled/Disabled: %s\n"
1648                 "Current Connect Status: %s\n"
1649                 "LPM Suspend Status: %s\n\n",
1650                 (tmp_reg & PORTS_PR) ? "Reset" : "Not Reset",
1651                 (tmp_reg & PORTS_SUSP) ? "Suspend " : "Not Suspend",
1652                 (tmp_reg & PORTS_OCC) ? "Detected" : "No",
1653                 (tmp_reg & PORTS_PEC) ? "Changed" : "Not Changed",
1654                 (tmp_reg & PORTS_PE) ? "Enable" : "Not Correct",
1655                 (tmp_reg & PORTS_CCS) ?  "Attached" : "Not Attached",
1656                 (tmp_reg & PORTS_SLP) ? "LPM L1" : "LPM L0");
1657         size -= t;
1658         next += t;
1659
1660         tmp_reg = readl(&dev->op_regs->devlc);
1661         t = scnprintf(next, size,
1662                 "Device LPM Control Reg:\n"
1663                 "Parallel Transceiver : %d\n"
1664                 "Serial Transceiver : %d\n"
1665                 "Port Speed: %s\n"
1666                 "Port Force Full Speed Connenct: %s\n"
1667                 "PHY Low Power Suspend Clock: %s\n"
1668                 "BmAttributes: %d\n\n",
1669                 LPM_PTS(tmp_reg),
1670                 (tmp_reg & LPM_STS) ? 1 : 0,
1671                 usb_speed_string(lpm_device_speed(tmp_reg)),
1672                 (tmp_reg & LPM_PFSC) ? "Force Full Speed" : "Not Force",
1673                 (tmp_reg & LPM_PHCD) ? "Disabled" : "Enabled",
1674                 LPM_BA(tmp_reg));
1675         size -= t;
1676         next += t;
1677
1678         tmp_reg = readl(&dev->op_regs->usbmode);
1679         t = scnprintf(next, size,
1680                         "USB Mode Reg:\n"
1681                         "Controller Mode is : %s\n\n", ({
1682                                 char *s;
1683                                 switch (MODE_CM(tmp_reg)) {
1684                                 case MODE_IDLE:
1685                                         s = "Idle"; break;
1686                                 case MODE_DEVICE:
1687                                         s = "Device Controller"; break;
1688                                 case MODE_HOST:
1689                                         s = "Host Controller"; break;
1690                                 default:
1691                                         s = "None"; break;
1692                                 }
1693                                 s;
1694                         }));
1695         size -= t;
1696         next += t;
1697
1698         tmp_reg = readl(&dev->op_regs->endptsetupstat);
1699         t = scnprintf(next, size,
1700                         "Endpoint Setup Status Reg:\n"
1701                         "SETUP on ep 0x%04x\n\n",
1702                         tmp_reg & SETUPSTAT_MASK);
1703         size -= t;
1704         next += t;
1705
1706         for (i = 0; i < dev->ep_max / 2; i++) {
1707                 tmp_reg = readl(&dev->op_regs->endptctrl[i]);
1708                 t = scnprintf(next, size, "EP Ctrl Reg [%d]: 0x%08x\n",
1709                                 i, tmp_reg);
1710                 size -= t;
1711                 next += t;
1712         }
1713         tmp_reg = readl(&dev->op_regs->endptprime);
1714         t = scnprintf(next, size, "EP Prime Reg: 0x%08x\n\n", tmp_reg);
1715         size -= t;
1716         next += t;
1717
1718         /* langwell_udc, langwell_ep, langwell_request structure information */
1719         ep = &dev->ep[0];
1720         t = scnprintf(next, size, "%s MaxPacketSize: 0x%x, ep_num: %d\n",
1721                         ep->ep.name, ep->ep.maxpacket, ep->ep_num);
1722         size -= t;
1723         next += t;
1724
1725         if (list_empty(&ep->queue)) {
1726                 t = scnprintf(next, size, "its req queue is empty\n\n");
1727                 size -= t;
1728                 next += t;
1729         } else {
1730                 list_for_each_entry(req, &ep->queue, queue) {
1731                         t = scnprintf(next, size,
1732                                 "req %p actual 0x%x length 0x%x  buf %p\n",
1733                                 &req->req, req->req.actual,
1734                                 req->req.length, req->req.buf);
1735                         size -= t;
1736                         next += t;
1737                 }
1738         }
1739         /* other gadget->eplist ep */
1740         list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
1741                 if (ep->desc) {
1742                         t = scnprintf(next, size,
1743                                         "\n%s MaxPacketSize: 0x%x, "
1744                                         "ep_num: %d\n",
1745                                         ep->ep.name, ep->ep.maxpacket,
1746                                         ep->ep_num);
1747                         size -= t;
1748                         next += t;
1749
1750                         if (list_empty(&ep->queue)) {
1751                                 t = scnprintf(next, size,
1752                                                 "its req queue is empty\n\n");
1753                                 size -= t;
1754                                 next += t;
1755                         } else {
1756                                 list_for_each_entry(req, &ep->queue, queue) {
1757                                         t = scnprintf(next, size,
1758                                                 "req %p actual 0x%x length "
1759                                                 "0x%x  buf %p\n",
1760                                                 &req->req, req->req.actual,
1761                                                 req->req.length, req->req.buf);
1762                                         size -= t;
1763                                         next += t;
1764                                 }
1765                         }
1766                 }
1767         }
1768
1769         spin_unlock_irqrestore(&dev->lock, flags);
1770         return PAGE_SIZE - size;
1771 }
1772 static DEVICE_ATTR(langwell_udc, S_IRUGO, show_langwell_udc, NULL);
1773
1774
1775 /* device "remote_wakeup" sysfs attribute file */
1776 static ssize_t store_remote_wakeup(struct device *_dev,
1777                 struct device_attribute *attr, const char *buf, size_t count)
1778 {
1779         struct langwell_udc     *dev = dev_get_drvdata(_dev);
1780         unsigned long           flags;
1781         ssize_t                 rc = count;
1782
1783         if (count > 2)
1784                 return -EINVAL;
1785
1786         if (count > 0 && buf[count-1] == '\n')
1787                 ((char *) buf)[count-1] = 0;
1788
1789         if (buf[0] != '1')
1790                 return -EINVAL;
1791
1792         /* force remote wakeup enabled in case gadget driver doesn't support */
1793         spin_lock_irqsave(&dev->lock, flags);
1794         dev->remote_wakeup = 1;
1795         dev->dev_status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1796         spin_unlock_irqrestore(&dev->lock, flags);
1797
1798         langwell_wakeup(&dev->gadget);
1799
1800         return rc;
1801 }
1802 static DEVICE_ATTR(remote_wakeup, S_IWUSR, NULL, store_remote_wakeup);
1803
1804
1805 /*-------------------------------------------------------------------------*/
1806
1807 /*
1808  * when a driver is successfully registered, it will receive
1809  * control requests including set_configuration(), which enables
1810  * non-control requests.  then usb traffic follows until a
1811  * disconnect is reported.  then a host may connect again, or
1812  * the driver might get unbound.
1813  */
1814
1815 static int langwell_start(struct usb_gadget *g,
1816                 struct usb_gadget_driver *driver)
1817 {
1818         struct langwell_udc     *dev = gadget_to_langwell(g);
1819         unsigned long           flags;
1820         int                     retval;
1821
1822         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1823
1824         spin_lock_irqsave(&dev->lock, flags);
1825
1826         /* hook up the driver ... */
1827         driver->driver.bus = NULL;
1828         dev->driver = driver;
1829         dev->gadget.dev.driver = &driver->driver;
1830
1831         spin_unlock_irqrestore(&dev->lock, flags);
1832
1833         retval = device_create_file(&dev->pdev->dev, &dev_attr_function);
1834         if (retval)
1835                 goto err;
1836
1837         dev->usb_state = USB_STATE_ATTACHED;
1838         dev->ep0_state = WAIT_FOR_SETUP;
1839         dev->ep0_dir = USB_DIR_OUT;
1840
1841         /* enable interrupt and set controller to run state */
1842         if (dev->got_irq)
1843                 langwell_udc_start(dev);
1844
1845         dev_vdbg(&dev->pdev->dev,
1846                         "After langwell_udc_start(), print all registers:\n");
1847         print_all_registers(dev);
1848
1849         dev_info(&dev->pdev->dev, "register driver: %s\n",
1850                         driver->driver.name);
1851         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1852
1853         return 0;
1854
1855 err:
1856         dev->gadget.dev.driver = NULL;
1857         dev->driver = NULL;
1858
1859         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1860
1861         return retval;
1862 }
1863
1864 /* unregister gadget driver */
1865 static int langwell_stop(struct usb_gadget *g,
1866                 struct usb_gadget_driver *driver)
1867 {
1868         struct langwell_udc     *dev = gadget_to_langwell(g);
1869         unsigned long           flags;
1870
1871         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
1872
1873         /* exit PHY low power suspend */
1874         if (dev->pdev->device != 0x0829)
1875                 langwell_phy_low_power(dev, 0);
1876
1877         /* unbind OTG transceiver */
1878         if (dev->transceiver)
1879                 (void)otg_set_peripheral(dev->transceiver->otg, 0);
1880
1881         /* disable interrupt and set controller to stop state */
1882         langwell_udc_stop(dev);
1883
1884         dev->usb_state = USB_STATE_ATTACHED;
1885         dev->ep0_state = WAIT_FOR_SETUP;
1886         dev->ep0_dir = USB_DIR_OUT;
1887
1888         spin_lock_irqsave(&dev->lock, flags);
1889
1890         /* stop all usb activities */
1891         dev->gadget.speed = USB_SPEED_UNKNOWN;
1892         dev->gadget.dev.driver = NULL;
1893         dev->driver = NULL;
1894         stop_activity(dev);
1895         spin_unlock_irqrestore(&dev->lock, flags);
1896
1897         device_remove_file(&dev->pdev->dev, &dev_attr_function);
1898
1899         dev_info(&dev->pdev->dev, "unregistered driver '%s'\n",
1900                         driver->driver.name);
1901         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1902
1903         return 0;
1904 }
1905
1906 /*-------------------------------------------------------------------------*/
1907
1908 /*
1909  * setup tripwire is used as a semaphore to ensure that the setup data
1910  * payload is extracted from a dQH without being corrupted
1911  */
1912 static void setup_tripwire(struct langwell_udc *dev)
1913 {
1914         u32                     usbcmd,
1915                                 endptsetupstat;
1916         unsigned long           timeout;
1917         struct langwell_dqh     *dqh;
1918
1919         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1920
1921         /* ep0 OUT dQH */
1922         dqh = &dev->ep_dqh[EP_DIR_OUT];
1923
1924         /* Write-Clear endptsetupstat */
1925         endptsetupstat = readl(&dev->op_regs->endptsetupstat);
1926         writel(endptsetupstat, &dev->op_regs->endptsetupstat);
1927
1928         /* wait until endptsetupstat is cleared */
1929         timeout = jiffies + SETUPSTAT_TIMEOUT;
1930         while (readl(&dev->op_regs->endptsetupstat)) {
1931                 if (time_after(jiffies, timeout)) {
1932                         dev_err(&dev->pdev->dev, "setup_tripwire timeout\n");
1933                         break;
1934                 }
1935                 cpu_relax();
1936         }
1937
1938         /* while a hazard exists when setup packet arrives */
1939         do {
1940                 /* set setup tripwire bit */
1941                 usbcmd = readl(&dev->op_regs->usbcmd);
1942                 writel(usbcmd | CMD_SUTW, &dev->op_regs->usbcmd);
1943
1944                 /* copy the setup packet to local buffer */
1945                 memcpy(&dev->local_setup_buff, &dqh->dqh_setup, 8);
1946         } while (!(readl(&dev->op_regs->usbcmd) & CMD_SUTW));
1947
1948         /* Write-Clear setup tripwire bit */
1949         usbcmd = readl(&dev->op_regs->usbcmd);
1950         writel(usbcmd & ~CMD_SUTW, &dev->op_regs->usbcmd);
1951
1952         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1953 }
1954
1955
1956 /* protocol ep0 stall, will automatically be cleared on new transaction */
1957 static void ep0_stall(struct langwell_udc *dev)
1958 {
1959         u32     endptctrl;
1960
1961         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1962
1963         /* set TX and RX to stall */
1964         endptctrl = readl(&dev->op_regs->endptctrl[0]);
1965         endptctrl |= EPCTRL_TXS | EPCTRL_RXS;
1966         writel(endptctrl, &dev->op_regs->endptctrl[0]);
1967
1968         /* update ep0 state */
1969         dev->ep0_state = WAIT_FOR_SETUP;
1970         dev->ep0_dir = USB_DIR_OUT;
1971
1972         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
1973 }
1974
1975
1976 /* PRIME a status phase for ep0 */
1977 static int prime_status_phase(struct langwell_udc *dev, int dir)
1978 {
1979         struct langwell_request *req;
1980         struct langwell_ep      *ep;
1981         int                     status = 0;
1982
1983         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
1984
1985         if (dir == EP_DIR_IN)
1986                 dev->ep0_dir = USB_DIR_IN;
1987         else
1988                 dev->ep0_dir = USB_DIR_OUT;
1989
1990         ep = &dev->ep[0];
1991         dev->ep0_state = WAIT_FOR_OUT_STATUS;
1992
1993         req = dev->status_req;
1994
1995         req->ep = ep;
1996         req->req.length = 0;
1997         req->req.status = -EINPROGRESS;
1998         req->req.actual = 0;
1999         req->req.complete = NULL;
2000         req->dtd_count = 0;
2001
2002         if (!req_to_dtd(req))
2003                 status = queue_dtd(ep, req);
2004         else
2005                 return -ENOMEM;
2006
2007         if (status)
2008                 dev_err(&dev->pdev->dev, "can't queue ep0 status request\n");
2009
2010         list_add_tail(&req->queue, &ep->queue);
2011
2012         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2013         return status;
2014 }
2015
2016
2017 /* SET_ADDRESS request routine */
2018 static void set_address(struct langwell_udc *dev, u16 value,
2019                 u16 index, u16 length)
2020 {
2021         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2022
2023         /* save the new address to device struct */
2024         dev->dev_addr = (u8) value;
2025         dev_vdbg(&dev->pdev->dev, "dev->dev_addr = %d\n", dev->dev_addr);
2026
2027         /* update usb state */
2028         dev->usb_state = USB_STATE_ADDRESS;
2029
2030         /* STATUS phase */
2031         if (prime_status_phase(dev, EP_DIR_IN))
2032                 ep0_stall(dev);
2033
2034         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2035 }
2036
2037
2038 /* return endpoint by windex */
2039 static struct langwell_ep *get_ep_by_windex(struct langwell_udc *dev,
2040                 u16 wIndex)
2041 {
2042         struct langwell_ep              *ep;
2043         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2044
2045         if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
2046                 return &dev->ep[0];
2047
2048         list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
2049                 u8      bEndpointAddress;
2050                 if (!ep->desc)
2051                         continue;
2052
2053                 bEndpointAddress = ep->desc->bEndpointAddress;
2054                 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
2055                         continue;
2056
2057                 if ((wIndex & USB_ENDPOINT_NUMBER_MASK)
2058                         == (bEndpointAddress & USB_ENDPOINT_NUMBER_MASK))
2059                         return ep;
2060         }
2061
2062         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2063         return NULL;
2064 }
2065
2066
2067 /* return whether endpoint is stalled, 0: not stalled; 1: stalled */
2068 static int ep_is_stall(struct langwell_ep *ep)
2069 {
2070         struct langwell_udc     *dev = ep->dev;
2071         u32                     endptctrl;
2072         int                     retval;
2073
2074         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2075
2076         endptctrl = readl(&dev->op_regs->endptctrl[ep->ep_num]);
2077         if (is_in(ep))
2078                 retval = endptctrl & EPCTRL_TXS ? 1 : 0;
2079         else
2080                 retval = endptctrl & EPCTRL_RXS ? 1 : 0;
2081
2082         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2083         return retval;
2084 }
2085
2086
2087 /* GET_STATUS request routine */
2088 static void get_status(struct langwell_udc *dev, u8 request_type, u16 value,
2089                 u16 index, u16 length)
2090 {
2091         struct langwell_request *req;
2092         struct langwell_ep      *ep;
2093         u16     status_data = 0;        /* 16 bits cpu view status data */
2094         int     status = 0;
2095
2096         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2097
2098         ep = &dev->ep[0];
2099
2100         if ((request_type & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
2101                 /* get device status */
2102                 status_data = dev->dev_status;
2103         } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_INTERFACE) {
2104                 /* get interface status */
2105                 status_data = 0;
2106         } else if ((request_type & USB_RECIP_MASK) == USB_RECIP_ENDPOINT) {
2107                 /* get endpoint status */
2108                 struct langwell_ep      *epn;
2109                 epn = get_ep_by_windex(dev, index);
2110                 /* stall if endpoint doesn't exist */
2111                 if (!epn)
2112                         goto stall;
2113
2114                 status_data = ep_is_stall(epn) << USB_ENDPOINT_HALT;
2115         }
2116
2117         dev_dbg(&dev->pdev->dev, "get status data: 0x%04x\n", status_data);
2118
2119         dev->ep0_dir = USB_DIR_IN;
2120
2121         /* borrow the per device status_req */
2122         req = dev->status_req;
2123
2124         /* fill in the reqest structure */
2125         *((u16 *) req->req.buf) = cpu_to_le16(status_data);
2126         req->ep = ep;
2127         req->req.length = 2;
2128         req->req.status = -EINPROGRESS;
2129         req->req.actual = 0;
2130         req->req.complete = NULL;
2131         req->dtd_count = 0;
2132
2133         /* prime the data phase */
2134         if (!req_to_dtd(req))
2135                 status = queue_dtd(ep, req);
2136         else                    /* no mem */
2137                 goto stall;
2138
2139         if (status) {
2140                 dev_err(&dev->pdev->dev,
2141                                 "response error on GET_STATUS request\n");
2142                 goto stall;
2143         }
2144
2145         list_add_tail(&req->queue, &ep->queue);
2146         dev->ep0_state = DATA_STATE_XMIT;
2147
2148         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2149         return;
2150 stall:
2151         ep0_stall(dev);
2152         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2153 }
2154
2155
2156 /* setup packet interrupt handler */
2157 static void handle_setup_packet(struct langwell_udc *dev,
2158                 struct usb_ctrlrequest *setup)
2159 {
2160         u16     wValue = le16_to_cpu(setup->wValue);
2161         u16     wIndex = le16_to_cpu(setup->wIndex);
2162         u16     wLength = le16_to_cpu(setup->wLength);
2163         u32     portsc1;
2164
2165         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2166
2167         /* ep0 fifo flush */
2168         nuke(&dev->ep[0], -ESHUTDOWN);
2169
2170         dev_dbg(&dev->pdev->dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
2171                         setup->bRequestType, setup->bRequest,
2172                         wValue, wIndex, wLength);
2173
2174         /* RNDIS gadget delegate */
2175         if ((setup->bRequestType == 0x21) && (setup->bRequest == 0x00)) {
2176                 /* USB_CDC_SEND_ENCAPSULATED_COMMAND */
2177                 goto delegate;
2178         }
2179
2180         /* USB_CDC_GET_ENCAPSULATED_RESPONSE */
2181         if ((setup->bRequestType == 0xa1) && (setup->bRequest == 0x01)) {
2182                 /* USB_CDC_GET_ENCAPSULATED_RESPONSE */
2183                 goto delegate;
2184         }
2185
2186         /* We process some stardard setup requests here */
2187         switch (setup->bRequest) {
2188         case USB_REQ_GET_STATUS:
2189                 dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_GET_STATUS\n");
2190                 /* get status, DATA and STATUS phase */
2191                 if ((setup->bRequestType & (USB_DIR_IN | USB_TYPE_MASK))
2192                                         != (USB_DIR_IN | USB_TYPE_STANDARD))
2193                         break;
2194                 get_status(dev, setup->bRequestType, wValue, wIndex, wLength);
2195                 goto end;
2196
2197         case USB_REQ_SET_ADDRESS:
2198                 dev_dbg(&dev->pdev->dev, "SETUP: USB_REQ_SET_ADDRESS\n");
2199                 /* STATUS phase */
2200                 if (setup->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD
2201                                                 | USB_RECIP_DEVICE))
2202                         break;
2203                 set_address(dev, wValue, wIndex, wLength);
2204                 goto end;
2205
2206         case USB_REQ_CLEAR_FEATURE:
2207         case USB_REQ_SET_FEATURE:
2208                 /* STATUS phase */
2209         {
2210                 int rc = -EOPNOTSUPP;
2211                 if (setup->bRequest == USB_REQ_SET_FEATURE)
2212                         dev_dbg(&dev->pdev->dev,
2213                                         "SETUP: USB_REQ_SET_FEATURE\n");
2214                 else if (setup->bRequest == USB_REQ_CLEAR_FEATURE)
2215                         dev_dbg(&dev->pdev->dev,
2216                                         "SETUP: USB_REQ_CLEAR_FEATURE\n");
2217
2218                 if ((setup->bRequestType & (USB_RECIP_MASK | USB_TYPE_MASK))
2219                                 == (USB_RECIP_ENDPOINT | USB_TYPE_STANDARD)) {
2220                         struct langwell_ep      *epn;
2221                         epn = get_ep_by_windex(dev, wIndex);
2222                         /* stall if endpoint doesn't exist */
2223                         if (!epn) {
2224                                 ep0_stall(dev);
2225                                 goto end;
2226                         }
2227
2228                         if (wValue != 0 || wLength != 0
2229                                         || epn->ep_num > dev->ep_max)
2230                                 break;
2231
2232                         spin_unlock(&dev->lock);
2233                         rc = langwell_ep_set_halt(&epn->ep,
2234                                 (setup->bRequest == USB_REQ_SET_FEATURE)
2235                                 ? 1 : 0);
2236                         spin_lock(&dev->lock);
2237
2238                 } else if ((setup->bRequestType & (USB_RECIP_MASK
2239                                 | USB_TYPE_MASK)) == (USB_RECIP_DEVICE
2240                                 | USB_TYPE_STANDARD)) {
2241                         rc = 0;
2242                         switch (wValue) {
2243                         case USB_DEVICE_REMOTE_WAKEUP:
2244                                 if (setup->bRequest == USB_REQ_SET_FEATURE) {
2245                                         dev->remote_wakeup = 1;
2246                                         dev->dev_status |= (1 << wValue);
2247                                 } else {
2248                                         dev->remote_wakeup = 0;
2249                                         dev->dev_status &= ~(1 << wValue);
2250                                 }
2251                                 break;
2252                         case USB_DEVICE_TEST_MODE:
2253                                 dev_dbg(&dev->pdev->dev, "SETUP: TEST MODE\n");
2254                                 if ((wIndex & 0xff) ||
2255                                         (dev->gadget.speed != USB_SPEED_HIGH))
2256                                         ep0_stall(dev);
2257
2258                                 switch (wIndex >> 8) {
2259                                 case TEST_J:
2260                                 case TEST_K:
2261                                 case TEST_SE0_NAK:
2262                                 case TEST_PACKET:
2263                                 case TEST_FORCE_EN:
2264                                         if (prime_status_phase(dev, EP_DIR_IN))
2265                                                 ep0_stall(dev);
2266                                         portsc1 = readl(&dev->op_regs->portsc1);
2267                                         portsc1 |= (wIndex & 0xf00) << 8;
2268                                         writel(portsc1, &dev->op_regs->portsc1);
2269                                         goto end;
2270                                 default:
2271                                         rc = -EOPNOTSUPP;
2272                                 }
2273                                 break;
2274                         default:
2275                                 rc = -EOPNOTSUPP;
2276                                 break;
2277                         }
2278
2279                         if (!gadget_is_otg(&dev->gadget))
2280                                 break;
2281                         else if (setup->bRequest == USB_DEVICE_B_HNP_ENABLE)
2282                                 dev->gadget.b_hnp_enable = 1;
2283                         else if (setup->bRequest == USB_DEVICE_A_HNP_SUPPORT)
2284                                 dev->gadget.a_hnp_support = 1;
2285                         else if (setup->bRequest ==
2286                                         USB_DEVICE_A_ALT_HNP_SUPPORT)
2287                                 dev->gadget.a_alt_hnp_support = 1;
2288                         else
2289                                 break;
2290                 } else
2291                         break;
2292
2293                 if (rc == 0) {
2294                         if (prime_status_phase(dev, EP_DIR_IN))
2295                                 ep0_stall(dev);
2296                 }
2297                 goto end;
2298         }
2299
2300         case USB_REQ_GET_DESCRIPTOR:
2301                 dev_dbg(&dev->pdev->dev,
2302                                 "SETUP: USB_REQ_GET_DESCRIPTOR\n");
2303                 goto delegate;
2304
2305         case USB_REQ_SET_DESCRIPTOR:
2306                 dev_dbg(&dev->pdev->dev,
2307                                 "SETUP: USB_REQ_SET_DESCRIPTOR unsupported\n");
2308                 goto delegate;
2309
2310         case USB_REQ_GET_CONFIGURATION:
2311                 dev_dbg(&dev->pdev->dev,
2312                                 "SETUP: USB_REQ_GET_CONFIGURATION\n");
2313                 goto delegate;
2314
2315         case USB_REQ_SET_CONFIGURATION:
2316                 dev_dbg(&dev->pdev->dev,
2317                                 "SETUP: USB_REQ_SET_CONFIGURATION\n");
2318                 goto delegate;
2319
2320         case USB_REQ_GET_INTERFACE:
2321                 dev_dbg(&dev->pdev->dev,
2322                                 "SETUP: USB_REQ_GET_INTERFACE\n");
2323                 goto delegate;
2324
2325         case USB_REQ_SET_INTERFACE:
2326                 dev_dbg(&dev->pdev->dev,
2327                                 "SETUP: USB_REQ_SET_INTERFACE\n");
2328                 goto delegate;
2329
2330         case USB_REQ_SYNCH_FRAME:
2331                 dev_dbg(&dev->pdev->dev,
2332                                 "SETUP: USB_REQ_SYNCH_FRAME unsupported\n");
2333                 goto delegate;
2334
2335         default:
2336                 /* delegate USB standard requests to the gadget driver */
2337                 goto delegate;
2338 delegate:
2339                 /* USB requests handled by gadget */
2340                 if (wLength) {
2341                         /* DATA phase from gadget, STATUS phase from udc */
2342                         dev->ep0_dir = (setup->bRequestType & USB_DIR_IN)
2343                                         ?  USB_DIR_IN : USB_DIR_OUT;
2344                         dev_vdbg(&dev->pdev->dev,
2345                                         "dev->ep0_dir = 0x%x, wLength = %d\n",
2346                                         dev->ep0_dir, wLength);
2347                         spin_unlock(&dev->lock);
2348                         if (dev->driver->setup(&dev->gadget,
2349                                         &dev->local_setup_buff) < 0)
2350                                 ep0_stall(dev);
2351                         spin_lock(&dev->lock);
2352                         dev->ep0_state = (setup->bRequestType & USB_DIR_IN)
2353                                         ?  DATA_STATE_XMIT : DATA_STATE_RECV;
2354                 } else {
2355                         /* no DATA phase, IN STATUS phase from gadget */
2356                         dev->ep0_dir = USB_DIR_IN;
2357                         dev_vdbg(&dev->pdev->dev,
2358                                         "dev->ep0_dir = 0x%x, wLength = %d\n",
2359                                         dev->ep0_dir, wLength);
2360                         spin_unlock(&dev->lock);
2361                         if (dev->driver->setup(&dev->gadget,
2362                                         &dev->local_setup_buff) < 0)
2363                                 ep0_stall(dev);
2364                         spin_lock(&dev->lock);
2365                         dev->ep0_state = WAIT_FOR_OUT_STATUS;
2366                 }
2367                 break;
2368         }
2369 end:
2370         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2371 }
2372
2373
2374 /* transfer completion, process endpoint request and free the completed dTDs
2375  * for this request
2376  */
2377 static int process_ep_req(struct langwell_udc *dev, int index,
2378                 struct langwell_request *curr_req)
2379 {
2380         struct langwell_dtd     *curr_dtd;
2381         struct langwell_dqh     *curr_dqh;
2382         int                     td_complete, actual, remaining_length;
2383         int                     i, dir;
2384         u8                      dtd_status = 0;
2385         int                     retval = 0;
2386
2387         curr_dqh = &dev->ep_dqh[index];
2388         dir = index % 2;
2389
2390         curr_dtd = curr_req->head;
2391         td_complete = 0;
2392         actual = curr_req->req.length;
2393
2394         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2395
2396         for (i = 0; i < curr_req->dtd_count; i++) {
2397
2398                 /* command execution states by dTD */
2399                 dtd_status = curr_dtd->dtd_status;
2400
2401                 barrier();
2402                 remaining_length = le16_to_cpu(curr_dtd->dtd_total);
2403                 actual -= remaining_length;
2404
2405                 if (!dtd_status) {
2406                         /* transfers completed successfully */
2407                         if (!remaining_length) {
2408                                 td_complete++;
2409                                 dev_vdbg(&dev->pdev->dev,
2410                                         "dTD transmitted successfully\n");
2411                         } else {
2412                                 if (dir) {
2413                                         dev_vdbg(&dev->pdev->dev,
2414                                                 "TX dTD remains data\n");
2415                                         retval = -EPROTO;
2416                                         break;
2417
2418                                 } else {
2419                                         td_complete++;
2420                                         break;
2421                                 }
2422                         }
2423                 } else {
2424                         /* transfers completed with errors */
2425                         if (dtd_status & DTD_STS_ACTIVE) {
2426                                 dev_dbg(&dev->pdev->dev,
2427                                         "dTD status ACTIVE dQH[%d]\n", index);
2428                                 retval = 1;
2429                                 return retval;
2430                         } else if (dtd_status & DTD_STS_HALTED) {
2431                                 dev_err(&dev->pdev->dev,
2432                                         "dTD error %08x dQH[%d]\n",
2433                                         dtd_status, index);
2434                                 /* clear the errors and halt condition */
2435                                 curr_dqh->dtd_status = 0;
2436                                 retval = -EPIPE;
2437                                 break;
2438                         } else if (dtd_status & DTD_STS_DBE) {
2439                                 dev_dbg(&dev->pdev->dev,
2440                                         "data buffer (overflow) error\n");
2441                                 retval = -EPROTO;
2442                                 break;
2443                         } else if (dtd_status & DTD_STS_TRE) {
2444                                 dev_dbg(&dev->pdev->dev,
2445                                         "transaction(ISO) error\n");
2446                                 retval = -EILSEQ;
2447                                 break;
2448                         } else
2449                                 dev_err(&dev->pdev->dev,
2450                                         "unknown error (0x%x)!\n",
2451                                         dtd_status);
2452                 }
2453
2454                 if (i != curr_req->dtd_count - 1)
2455                         curr_dtd = (struct langwell_dtd *)
2456                                 curr_dtd->next_dtd_virt;
2457         }
2458
2459         if (retval)
2460                 return retval;
2461
2462         curr_req->req.actual = actual;
2463
2464         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2465         return 0;
2466 }
2467
2468
2469 /* complete DATA or STATUS phase of ep0 prime status phase if needed */
2470 static void ep0_req_complete(struct langwell_udc *dev,
2471                 struct langwell_ep *ep0, struct langwell_request *req)
2472 {
2473         u32     new_addr;
2474         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2475
2476         if (dev->usb_state == USB_STATE_ADDRESS) {
2477                 /* set the new address */
2478                 new_addr = (u32)dev->dev_addr;
2479                 writel(new_addr << USBADR_SHIFT, &dev->op_regs->deviceaddr);
2480
2481                 new_addr = USBADR(readl(&dev->op_regs->deviceaddr));
2482                 dev_vdbg(&dev->pdev->dev, "new_addr = %d\n", new_addr);
2483         }
2484
2485         done(ep0, req, 0);
2486
2487         switch (dev->ep0_state) {
2488         case DATA_STATE_XMIT:
2489                 /* receive status phase */
2490                 if (prime_status_phase(dev, EP_DIR_OUT))
2491                         ep0_stall(dev);
2492                 break;
2493         case DATA_STATE_RECV:
2494                 /* send status phase */
2495                 if (prime_status_phase(dev, EP_DIR_IN))
2496                         ep0_stall(dev);
2497                 break;
2498         case WAIT_FOR_OUT_STATUS:
2499                 dev->ep0_state = WAIT_FOR_SETUP;
2500                 break;
2501         case WAIT_FOR_SETUP:
2502                 dev_err(&dev->pdev->dev, "unexpect ep0 packets\n");
2503                 break;
2504         default:
2505                 ep0_stall(dev);
2506                 break;
2507         }
2508
2509         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2510 }
2511
2512
2513 /* USB transfer completion interrupt */
2514 static void handle_trans_complete(struct langwell_udc *dev)
2515 {
2516         u32                     complete_bits;
2517         int                     i, ep_num, dir, bit_mask, status;
2518         struct langwell_ep      *epn;
2519         struct langwell_request *curr_req, *temp_req;
2520
2521         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2522
2523         complete_bits = readl(&dev->op_regs->endptcomplete);
2524         dev_vdbg(&dev->pdev->dev, "endptcomplete register: 0x%08x\n",
2525                         complete_bits);
2526
2527         /* Write-Clear the bits in endptcomplete register */
2528         writel(complete_bits, &dev->op_regs->endptcomplete);
2529
2530         if (!complete_bits) {
2531                 dev_dbg(&dev->pdev->dev, "complete_bits = 0\n");
2532                 goto done;
2533         }
2534
2535         for (i = 0; i < dev->ep_max; i++) {
2536                 ep_num = i / 2;
2537                 dir = i % 2;
2538
2539                 bit_mask = 1 << (ep_num + 16 * dir);
2540
2541                 if (!(complete_bits & bit_mask))
2542                         continue;
2543
2544                 /* ep0 */
2545                 if (i == 1)
2546                         epn = &dev->ep[0];
2547                 else
2548                         epn = &dev->ep[i];
2549
2550                 if (epn->name == NULL) {
2551                         dev_warn(&dev->pdev->dev, "invalid endpoint\n");
2552                         continue;
2553                 }
2554
2555                 if (i < 2)
2556                         /* ep0 in and out */
2557                         dev_dbg(&dev->pdev->dev, "%s-%s transfer completed\n",
2558                                         epn->name,
2559                                         is_in(epn) ? "in" : "out");
2560                 else
2561                         dev_dbg(&dev->pdev->dev, "%s transfer completed\n",
2562                                         epn->name);
2563
2564                 /* process the req queue until an uncomplete request */
2565                 list_for_each_entry_safe(curr_req, temp_req,
2566                                 &epn->queue, queue) {
2567                         status = process_ep_req(dev, i, curr_req);
2568                         dev_vdbg(&dev->pdev->dev, "%s req status: %d\n",
2569                                         epn->name, status);
2570
2571                         if (status)
2572                                 break;
2573
2574                         /* write back status to req */
2575                         curr_req->req.status = status;
2576
2577                         /* ep0 request completion */
2578                         if (ep_num == 0) {
2579                                 ep0_req_complete(dev, epn, curr_req);
2580                                 break;
2581                         } else {
2582                                 done(epn, curr_req, status);
2583                         }
2584                 }
2585         }
2586 done:
2587         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2588 }
2589
2590 /* port change detect interrupt handler */
2591 static void handle_port_change(struct langwell_udc *dev)
2592 {
2593         u32     portsc1, devlc;
2594
2595         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2596
2597         if (dev->bus_reset)
2598                 dev->bus_reset = 0;
2599
2600         portsc1 = readl(&dev->op_regs->portsc1);
2601         devlc = readl(&dev->op_regs->devlc);
2602         dev_vdbg(&dev->pdev->dev, "portsc1 = 0x%08x, devlc = 0x%08x\n",
2603                         portsc1, devlc);
2604
2605         /* bus reset is finished */
2606         if (!(portsc1 & PORTS_PR)) {
2607                 /* get the speed */
2608                 dev->gadget.speed = lpm_device_speed(devlc);
2609                 dev_vdbg(&dev->pdev->dev, "dev->gadget.speed = %d\n",
2610                         dev->gadget.speed);
2611         }
2612
2613         /* LPM L0 to L1 */
2614         if (dev->lpm && dev->lpm_state == LPM_L0)
2615                 if (portsc1 & PORTS_SUSP && portsc1 & PORTS_SLP) {
2616                         dev_info(&dev->pdev->dev, "LPM L0 to L1\n");
2617                         dev->lpm_state = LPM_L1;
2618                 }
2619
2620         /* LPM L1 to L0, force resume or remote wakeup finished */
2621         if (dev->lpm && dev->lpm_state == LPM_L1)
2622                 if (!(portsc1 & PORTS_SUSP)) {
2623                         dev_info(&dev->pdev->dev, "LPM L1 to L0\n");
2624                         dev->lpm_state = LPM_L0;
2625                 }
2626
2627         /* update USB state */
2628         if (!dev->resume_state)
2629                 dev->usb_state = USB_STATE_DEFAULT;
2630
2631         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2632 }
2633
2634
2635 /* USB reset interrupt handler */
2636 static void handle_usb_reset(struct langwell_udc *dev)
2637 {
2638         u32             deviceaddr,
2639                         endptsetupstat,
2640                         endptcomplete;
2641         unsigned long   timeout;
2642
2643         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2644
2645         /* Write-Clear the device address */
2646         deviceaddr = readl(&dev->op_regs->deviceaddr);
2647         writel(deviceaddr & ~USBADR_MASK, &dev->op_regs->deviceaddr);
2648
2649         dev->dev_addr = 0;
2650
2651         /* clear usb state */
2652         dev->resume_state = 0;
2653
2654         /* LPM L1 to L0, reset */
2655         if (dev->lpm)
2656                 dev->lpm_state = LPM_L0;
2657
2658         dev->ep0_dir = USB_DIR_OUT;
2659         dev->ep0_state = WAIT_FOR_SETUP;
2660
2661         /* remote wakeup reset to 0 when the device is reset */
2662         dev->remote_wakeup = 0;
2663         dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
2664         dev->gadget.b_hnp_enable = 0;
2665         dev->gadget.a_hnp_support = 0;
2666         dev->gadget.a_alt_hnp_support = 0;
2667
2668         /* Write-Clear all the setup token semaphores */
2669         endptsetupstat = readl(&dev->op_regs->endptsetupstat);
2670         writel(endptsetupstat, &dev->op_regs->endptsetupstat);
2671
2672         /* Write-Clear all the endpoint complete status bits */
2673         endptcomplete = readl(&dev->op_regs->endptcomplete);
2674         writel(endptcomplete, &dev->op_regs->endptcomplete);
2675
2676         /* wait until all endptprime bits cleared */
2677         timeout = jiffies + PRIME_TIMEOUT;
2678         while (readl(&dev->op_regs->endptprime)) {
2679                 if (time_after(jiffies, timeout)) {
2680                         dev_err(&dev->pdev->dev, "USB reset timeout\n");
2681                         break;
2682                 }
2683                 cpu_relax();
2684         }
2685
2686         /* write 1s to endptflush register to clear any primed buffers */
2687         writel((u32) ~0, &dev->op_regs->endptflush);
2688
2689         if (readl(&dev->op_regs->portsc1) & PORTS_PR) {
2690                 dev_vdbg(&dev->pdev->dev, "USB bus reset\n");
2691                 /* bus is reseting */
2692                 dev->bus_reset = 1;
2693
2694                 /* reset all the queues, stop all USB activities */
2695                 stop_activity(dev);
2696                 dev->usb_state = USB_STATE_DEFAULT;
2697         } else {
2698                 dev_vdbg(&dev->pdev->dev, "device controller reset\n");
2699                 /* controller reset */
2700                 langwell_udc_reset(dev);
2701
2702                 /* reset all the queues, stop all USB activities */
2703                 stop_activity(dev);
2704
2705                 /* reset ep0 dQH and endptctrl */
2706                 ep0_reset(dev);
2707
2708                 /* enable interrupt and set controller to run state */
2709                 langwell_udc_start(dev);
2710
2711                 dev->usb_state = USB_STATE_ATTACHED;
2712         }
2713
2714         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2715 }
2716
2717
2718 /* USB bus suspend/resume interrupt */
2719 static void handle_bus_suspend(struct langwell_udc *dev)
2720 {
2721         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2722
2723         dev->resume_state = dev->usb_state;
2724         dev->usb_state = USB_STATE_SUSPENDED;
2725
2726         /* report suspend to the driver */
2727         if (dev->driver) {
2728                 if (dev->driver->suspend) {
2729                         spin_unlock(&dev->lock);
2730                         dev->driver->suspend(&dev->gadget);
2731                         spin_lock(&dev->lock);
2732                         dev_dbg(&dev->pdev->dev, "suspend %s\n",
2733                                         dev->driver->driver.name);
2734                 }
2735         }
2736
2737         /* enter PHY low power suspend */
2738         if (dev->pdev->device != 0x0829)
2739                 langwell_phy_low_power(dev, 0);
2740
2741         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2742 }
2743
2744
2745 static void handle_bus_resume(struct langwell_udc *dev)
2746 {
2747         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2748
2749         dev->usb_state = dev->resume_state;
2750         dev->resume_state = 0;
2751
2752         /* exit PHY low power suspend */
2753         if (dev->pdev->device != 0x0829)
2754                 langwell_phy_low_power(dev, 0);
2755
2756         /* report resume to the driver */
2757         if (dev->driver) {
2758                 if (dev->driver->resume) {
2759                         spin_unlock(&dev->lock);
2760                         dev->driver->resume(&dev->gadget);
2761                         spin_lock(&dev->lock);
2762                         dev_dbg(&dev->pdev->dev, "resume %s\n",
2763                                         dev->driver->driver.name);
2764                 }
2765         }
2766
2767         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2768 }
2769
2770
2771 /* USB device controller interrupt handler */
2772 static irqreturn_t langwell_irq(int irq, void *_dev)
2773 {
2774         struct langwell_udc     *dev = _dev;
2775         u32                     usbsts,
2776                                 usbintr,
2777                                 irq_sts,
2778                                 portsc1;
2779
2780         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
2781
2782         if (dev->stopped) {
2783                 dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
2784                 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2785                 return IRQ_NONE;
2786         }
2787
2788         spin_lock(&dev->lock);
2789
2790         /* USB status */
2791         usbsts = readl(&dev->op_regs->usbsts);
2792
2793         /* USB interrupt enable */
2794         usbintr = readl(&dev->op_regs->usbintr);
2795
2796         irq_sts = usbsts & usbintr;
2797         dev_vdbg(&dev->pdev->dev,
2798                         "usbsts = 0x%08x, usbintr = 0x%08x, irq_sts = 0x%08x\n",
2799                         usbsts, usbintr, irq_sts);
2800
2801         if (!irq_sts) {
2802                 dev_vdbg(&dev->pdev->dev, "handle IRQ_NONE\n");
2803                 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2804                 spin_unlock(&dev->lock);
2805                 return IRQ_NONE;
2806         }
2807
2808         /* Write-Clear interrupt status bits */
2809         writel(irq_sts, &dev->op_regs->usbsts);
2810
2811         /* resume from suspend */
2812         portsc1 = readl(&dev->op_regs->portsc1);
2813         if (dev->usb_state == USB_STATE_SUSPENDED)
2814                 if (!(portsc1 & PORTS_SUSP))
2815                         handle_bus_resume(dev);
2816
2817         /* USB interrupt */
2818         if (irq_sts & STS_UI) {
2819                 dev_vdbg(&dev->pdev->dev, "USB interrupt\n");
2820
2821                 /* setup packet received from ep0 */
2822                 if (readl(&dev->op_regs->endptsetupstat)
2823                                 & EP0SETUPSTAT_MASK) {
2824                         dev_vdbg(&dev->pdev->dev,
2825                                 "USB SETUP packet received interrupt\n");
2826                         /* setup tripwire semaphone */
2827                         setup_tripwire(dev);
2828                         handle_setup_packet(dev, &dev->local_setup_buff);
2829                 }
2830
2831                 /* USB transfer completion */
2832                 if (readl(&dev->op_regs->endptcomplete)) {
2833                         dev_vdbg(&dev->pdev->dev,
2834                                 "USB transfer completion interrupt\n");
2835                         handle_trans_complete(dev);
2836                 }
2837         }
2838
2839         /* SOF received interrupt (for ISO transfer) */
2840         if (irq_sts & STS_SRI) {
2841                 /* FIXME */
2842                 /* dev_vdbg(&dev->pdev->dev, "SOF received interrupt\n"); */
2843         }
2844
2845         /* port change detect interrupt */
2846         if (irq_sts & STS_PCI) {
2847                 dev_vdbg(&dev->pdev->dev, "port change detect interrupt\n");
2848                 handle_port_change(dev);
2849         }
2850
2851         /* suspend interrupt */
2852         if (irq_sts & STS_SLI) {
2853                 dev_vdbg(&dev->pdev->dev, "suspend interrupt\n");
2854                 handle_bus_suspend(dev);
2855         }
2856
2857         /* USB reset interrupt */
2858         if (irq_sts & STS_URI) {
2859                 dev_vdbg(&dev->pdev->dev, "USB reset interrupt\n");
2860                 handle_usb_reset(dev);
2861         }
2862
2863         /* USB error or system error interrupt */
2864         if (irq_sts & (STS_UEI | STS_SEI)) {
2865                 /* FIXME */
2866                 dev_warn(&dev->pdev->dev, "error IRQ, irq_sts: %x\n", irq_sts);
2867         }
2868
2869         spin_unlock(&dev->lock);
2870
2871         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2872         return IRQ_HANDLED;
2873 }
2874
2875
2876 /*-------------------------------------------------------------------------*/
2877
2878 /* release device structure */
2879 static void gadget_release(struct device *_dev)
2880 {
2881         struct langwell_udc     *dev = dev_get_drvdata(_dev);
2882
2883         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2884
2885         complete(dev->done);
2886
2887         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2888         kfree(dev);
2889 }
2890
2891
2892 /* enable SRAM caching if SRAM detected */
2893 static void sram_init(struct langwell_udc *dev)
2894 {
2895         struct pci_dev          *pdev = dev->pdev;
2896
2897         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2898
2899         dev->sram_addr = pci_resource_start(pdev, 1);
2900         dev->sram_size = pci_resource_len(pdev, 1);
2901         dev_info(&dev->pdev->dev, "Found private SRAM at %x size:%x\n",
2902                         dev->sram_addr, dev->sram_size);
2903         dev->got_sram = 1;
2904
2905         if (pci_request_region(pdev, 1, kobject_name(&pdev->dev.kobj))) {
2906                 dev_warn(&dev->pdev->dev, "SRAM request failed\n");
2907                 dev->got_sram = 0;
2908         } else if (!dma_declare_coherent_memory(&pdev->dev, dev->sram_addr,
2909                         dev->sram_addr, dev->sram_size, DMA_MEMORY_MAP)) {
2910                 dev_warn(&dev->pdev->dev, "SRAM DMA declare failed\n");
2911                 pci_release_region(pdev, 1);
2912                 dev->got_sram = 0;
2913         }
2914
2915         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2916 }
2917
2918
2919 /* release SRAM caching */
2920 static void sram_deinit(struct langwell_udc *dev)
2921 {
2922         struct pci_dev *pdev = dev->pdev;
2923
2924         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2925
2926         dma_release_declared_memory(&pdev->dev);
2927         pci_release_region(pdev, 1);
2928
2929         dev->got_sram = 0;
2930
2931         dev_info(&dev->pdev->dev, "release SRAM caching\n");
2932         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2933 }
2934
2935
2936 /* tear down the binding between this driver and the pci device */
2937 static void langwell_udc_remove(struct pci_dev *pdev)
2938 {
2939         struct langwell_udc     *dev = pci_get_drvdata(pdev);
2940
2941         DECLARE_COMPLETION(done);
2942
2943         BUG_ON(dev->driver);
2944         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
2945
2946         dev->done = &done;
2947
2948         /* free dTD dma_pool and dQH */
2949         if (dev->dtd_pool)
2950                 dma_pool_destroy(dev->dtd_pool);
2951
2952         if (dev->ep_dqh)
2953                 dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
2954                         dev->ep_dqh, dev->ep_dqh_dma);
2955
2956         /* release SRAM caching */
2957         if (dev->has_sram && dev->got_sram)
2958                 sram_deinit(dev);
2959
2960         if (dev->status_req) {
2961                 kfree(dev->status_req->req.buf);
2962                 kfree(dev->status_req);
2963         }
2964
2965         kfree(dev->ep);
2966
2967         /* disable IRQ handler */
2968         if (dev->got_irq)
2969                 free_irq(pdev->irq, dev);
2970
2971         if (dev->cap_regs)
2972                 iounmap(dev->cap_regs);
2973
2974         if (dev->region)
2975                 release_mem_region(pci_resource_start(pdev, 0),
2976                                 pci_resource_len(pdev, 0));
2977
2978         if (dev->enabled)
2979                 pci_disable_device(pdev);
2980
2981         dev->cap_regs = NULL;
2982
2983         dev_info(&dev->pdev->dev, "unbind\n");
2984         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
2985
2986         device_unregister(&dev->gadget.dev);
2987         device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
2988         device_remove_file(&pdev->dev, &dev_attr_remote_wakeup);
2989
2990         pci_set_drvdata(pdev, NULL);
2991
2992         /* free dev, wait for the release() finished */
2993         wait_for_completion(&done);
2994 }
2995
2996
2997 /*
2998  * wrap this driver around the specified device, but
2999  * don't respond over USB until a gadget driver binds to us.
3000  */
3001 static int langwell_udc_probe(struct pci_dev *pdev,
3002                 const struct pci_device_id *id)
3003 {
3004         struct langwell_udc     *dev;
3005         unsigned long           resource, len;
3006         void                    __iomem *base = NULL;
3007         size_t                  size;
3008         int                     retval;
3009
3010         /* alloc, and start init */
3011         dev = kzalloc(sizeof *dev, GFP_KERNEL);
3012         if (dev == NULL) {
3013                 retval = -ENOMEM;
3014                 goto error;
3015         }
3016
3017         /* initialize device spinlock */
3018         spin_lock_init(&dev->lock);
3019
3020         dev->pdev = pdev;
3021         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3022
3023         pci_set_drvdata(pdev, dev);
3024
3025         /* now all the pci goodies ... */
3026         if (pci_enable_device(pdev) < 0) {
3027                 retval = -ENODEV;
3028                 goto error;
3029         }
3030         dev->enabled = 1;
3031
3032         /* control register: BAR 0 */
3033         resource = pci_resource_start(pdev, 0);
3034         len = pci_resource_len(pdev, 0);
3035         if (!request_mem_region(resource, len, driver_name)) {
3036                 dev_err(&dev->pdev->dev, "controller already in use\n");
3037                 retval = -EBUSY;
3038                 goto error;
3039         }
3040         dev->region = 1;
3041
3042         base = ioremap_nocache(resource, len);
3043         if (base == NULL) {
3044                 dev_err(&dev->pdev->dev, "can't map memory\n");
3045                 retval = -EFAULT;
3046                 goto error;
3047         }
3048
3049         dev->cap_regs = (struct langwell_cap_regs __iomem *) base;
3050         dev_vdbg(&dev->pdev->dev, "dev->cap_regs: %p\n", dev->cap_regs);
3051         dev->op_regs = (struct langwell_op_regs __iomem *)
3052                 (base + OP_REG_OFFSET);
3053         dev_vdbg(&dev->pdev->dev, "dev->op_regs: %p\n", dev->op_regs);
3054
3055         /* irq setup after old hardware is cleaned up */
3056         if (!pdev->irq) {
3057                 dev_err(&dev->pdev->dev, "No IRQ. Check PCI setup!\n");
3058                 retval = -ENODEV;
3059                 goto error;
3060         }
3061
3062         dev->has_sram = 1;
3063         dev->got_sram = 0;
3064         dev_vdbg(&dev->pdev->dev, "dev->has_sram: %d\n", dev->has_sram);
3065
3066         /* enable SRAM caching if detected */
3067         if (dev->has_sram && !dev->got_sram)
3068                 sram_init(dev);
3069
3070         dev_info(&dev->pdev->dev,
3071                         "irq %d, io mem: 0x%08lx, len: 0x%08lx, pci mem 0x%p\n",
3072                         pdev->irq, resource, len, base);
3073         /* enables bus-mastering for device dev */
3074         pci_set_master(pdev);
3075
3076         if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
3077                                 driver_name, dev) != 0) {
3078                 dev_err(&dev->pdev->dev,
3079                                 "request interrupt %d failed\n", pdev->irq);
3080                 retval = -EBUSY;
3081                 goto error;
3082         }
3083         dev->got_irq = 1;
3084
3085         /* set stopped bit */
3086         dev->stopped = 1;
3087
3088         /* capabilities and endpoint number */
3089         dev->lpm = (readl(&dev->cap_regs->hccparams) & HCC_LEN) ? 1 : 0;
3090         dev->dciversion = readw(&dev->cap_regs->dciversion);
3091         dev->devcap = (readl(&dev->cap_regs->dccparams) & DEVCAP) ? 1 : 0;
3092         dev_vdbg(&dev->pdev->dev, "dev->lpm: %d\n", dev->lpm);
3093         dev_vdbg(&dev->pdev->dev, "dev->dciversion: 0x%04x\n",
3094                         dev->dciversion);
3095         dev_vdbg(&dev->pdev->dev, "dccparams: 0x%08x\n",
3096                         readl(&dev->cap_regs->dccparams));
3097         dev_vdbg(&dev->pdev->dev, "dev->devcap: %d\n", dev->devcap);
3098         if (!dev->devcap) {
3099                 dev_err(&dev->pdev->dev, "can't support device mode\n");
3100                 retval = -ENODEV;
3101                 goto error;
3102         }
3103
3104         /* a pair of endpoints (out/in) for each address */
3105         dev->ep_max = DEN(readl(&dev->cap_regs->dccparams)) * 2;
3106         dev_vdbg(&dev->pdev->dev, "dev->ep_max: %d\n", dev->ep_max);
3107
3108         /* allocate endpoints memory */
3109         dev->ep = kzalloc(sizeof(struct langwell_ep) * dev->ep_max,
3110                         GFP_KERNEL);
3111         if (!dev->ep) {
3112                 dev_err(&dev->pdev->dev, "allocate endpoints memory failed\n");
3113                 retval = -ENOMEM;
3114                 goto error;
3115         }
3116
3117         /* allocate device dQH memory */
3118         size = dev->ep_max * sizeof(struct langwell_dqh);
3119         dev_vdbg(&dev->pdev->dev, "orig size = %zd\n", size);
3120         if (size < DQH_ALIGNMENT)
3121                 size = DQH_ALIGNMENT;
3122         else if ((size % DQH_ALIGNMENT) != 0) {
3123                 size += DQH_ALIGNMENT + 1;
3124                 size &= ~(DQH_ALIGNMENT - 1);
3125         }
3126         dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
3127                                         &dev->ep_dqh_dma, GFP_KERNEL);
3128         if (!dev->ep_dqh) {
3129                 dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
3130                 retval = -ENOMEM;
3131                 goto error;
3132         }
3133         dev->ep_dqh_size = size;
3134         dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %zd\n", dev->ep_dqh_size);
3135
3136         /* initialize ep0 status request structure */
3137         dev->status_req = kzalloc(sizeof(struct langwell_request), GFP_KERNEL);
3138         if (!dev->status_req) {
3139                 dev_err(&dev->pdev->dev,
3140                                 "allocate status_req memory failed\n");
3141                 retval = -ENOMEM;
3142                 goto error;
3143         }
3144         INIT_LIST_HEAD(&dev->status_req->queue);
3145
3146         /* allocate a small amount of memory to get valid address */
3147         dev->status_req->req.buf = kmalloc(8, GFP_KERNEL);
3148         dev->status_req->req.dma = virt_to_phys(dev->status_req->req.buf);
3149
3150         dev->resume_state = USB_STATE_NOTATTACHED;
3151         dev->usb_state = USB_STATE_POWERED;
3152         dev->ep0_dir = USB_DIR_OUT;
3153
3154         /* remote wakeup reset to 0 when the device is reset */
3155         dev->remote_wakeup = 0;
3156         dev->dev_status = 1 << USB_DEVICE_SELF_POWERED;
3157
3158         /* reset device controller */
3159         langwell_udc_reset(dev);
3160
3161         /* initialize gadget structure */
3162         dev->gadget.ops = &langwell_ops;        /* usb_gadget_ops */
3163         dev->gadget.ep0 = &dev->ep[0].ep;       /* gadget ep0 */
3164         INIT_LIST_HEAD(&dev->gadget.ep_list);   /* ep_list */
3165         dev->gadget.speed = USB_SPEED_UNKNOWN;  /* speed */
3166         dev->gadget.max_speed = USB_SPEED_HIGH; /* support dual speed */
3167
3168         /* the "gadget" abstracts/virtualizes the controller */
3169         dev_set_name(&dev->gadget.dev, "gadget");
3170         dev->gadget.dev.parent = &pdev->dev;
3171         dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
3172         dev->gadget.dev.release = gadget_release;
3173         dev->gadget.name = driver_name;         /* gadget name */
3174
3175         /* controller endpoints reinit */
3176         eps_reinit(dev);
3177
3178         /* reset ep0 dQH and endptctrl */
3179         ep0_reset(dev);
3180
3181         /* create dTD dma_pool resource */
3182         dev->dtd_pool = dma_pool_create("langwell_dtd",
3183                         &dev->pdev->dev,
3184                         sizeof(struct langwell_dtd),
3185                         DTD_ALIGNMENT,
3186                         DMA_BOUNDARY);
3187
3188         if (!dev->dtd_pool) {
3189                 retval = -ENOMEM;
3190                 goto error;
3191         }
3192
3193         /* done */
3194         dev_info(&dev->pdev->dev, "%s\n", driver_desc);
3195         dev_info(&dev->pdev->dev, "irq %d, pci mem %p\n", pdev->irq, base);
3196         dev_info(&dev->pdev->dev, "Driver version: " DRIVER_VERSION "\n");
3197         dev_info(&dev->pdev->dev, "Support (max) %d endpoints\n", dev->ep_max);
3198         dev_info(&dev->pdev->dev, "Device interface version: 0x%04x\n",
3199                         dev->dciversion);
3200         dev_info(&dev->pdev->dev, "Controller mode: %s\n",
3201                         dev->devcap ? "Device" : "Host");
3202         dev_info(&dev->pdev->dev, "Support USB LPM: %s\n",
3203                         dev->lpm ? "Yes" : "No");
3204
3205         dev_vdbg(&dev->pdev->dev,
3206                         "After langwell_udc_probe(), print all registers:\n");
3207         print_all_registers(dev);
3208
3209         retval = device_register(&dev->gadget.dev);
3210         if (retval)
3211                 goto error;
3212
3213         retval = usb_add_gadget_udc(&pdev->dev, &dev->gadget);
3214         if (retval)
3215                 goto error;
3216
3217         retval = device_create_file(&pdev->dev, &dev_attr_langwell_udc);
3218         if (retval)
3219                 goto error;
3220
3221         retval = device_create_file(&pdev->dev, &dev_attr_remote_wakeup);
3222         if (retval)
3223                 goto error_attr1;
3224
3225         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3226         return 0;
3227
3228 error_attr1:
3229         device_remove_file(&pdev->dev, &dev_attr_langwell_udc);
3230 error:
3231         if (dev) {
3232                 dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3233                 langwell_udc_remove(pdev);
3234         }
3235
3236         return retval;
3237 }
3238
3239
3240 /* device controller suspend */
3241 static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state)
3242 {
3243         struct langwell_udc     *dev = pci_get_drvdata(pdev);
3244
3245         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3246
3247         usb_del_gadget_udc(&dev->gadget);
3248         /* disable interrupt and set controller to stop state */
3249         langwell_udc_stop(dev);
3250
3251         /* disable IRQ handler */
3252         if (dev->got_irq)
3253                 free_irq(pdev->irq, dev);
3254         dev->got_irq = 0;
3255
3256         /* save PCI state */
3257         pci_save_state(pdev);
3258
3259         spin_lock_irq(&dev->lock);
3260         /* stop all usb activities */
3261         stop_activity(dev);
3262         spin_unlock_irq(&dev->lock);
3263
3264         /* free dTD dma_pool and dQH */
3265         if (dev->dtd_pool)
3266                 dma_pool_destroy(dev->dtd_pool);
3267
3268         if (dev->ep_dqh)
3269                 dma_free_coherent(&pdev->dev, dev->ep_dqh_size,
3270                         dev->ep_dqh, dev->ep_dqh_dma);
3271
3272         /* release SRAM caching */
3273         if (dev->has_sram && dev->got_sram)
3274                 sram_deinit(dev);
3275
3276         /* set device power state */
3277         pci_set_power_state(pdev, PCI_D3hot);
3278
3279         /* enter PHY low power suspend */
3280         if (dev->pdev->device != 0x0829)
3281                 langwell_phy_low_power(dev, 1);
3282
3283         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3284         return 0;
3285 }
3286
3287
3288 /* device controller resume */
3289 static int langwell_udc_resume(struct pci_dev *pdev)
3290 {
3291         struct langwell_udc     *dev = pci_get_drvdata(pdev);
3292         size_t                  size;
3293
3294         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3295
3296         /* exit PHY low power suspend */
3297         if (dev->pdev->device != 0x0829)
3298                 langwell_phy_low_power(dev, 0);
3299
3300         /* set device D0 power state */
3301         pci_set_power_state(pdev, PCI_D0);
3302
3303         /* enable SRAM caching if detected */
3304         if (dev->has_sram && !dev->got_sram)
3305                 sram_init(dev);
3306
3307         /* allocate device dQH memory */
3308         size = dev->ep_max * sizeof(struct langwell_dqh);
3309         dev_vdbg(&dev->pdev->dev, "orig size = %zd\n", size);
3310         if (size < DQH_ALIGNMENT)
3311                 size = DQH_ALIGNMENT;
3312         else if ((size % DQH_ALIGNMENT) != 0) {
3313                 size += DQH_ALIGNMENT + 1;
3314                 size &= ~(DQH_ALIGNMENT - 1);
3315         }
3316         dev->ep_dqh = dma_alloc_coherent(&pdev->dev, size,
3317                                         &dev->ep_dqh_dma, GFP_KERNEL);
3318         if (!dev->ep_dqh) {
3319                 dev_err(&dev->pdev->dev, "allocate dQH memory failed\n");
3320                 return -ENOMEM;
3321         }
3322         dev->ep_dqh_size = size;
3323         dev_vdbg(&dev->pdev->dev, "ep_dqh_size = %zd\n", dev->ep_dqh_size);
3324
3325         /* create dTD dma_pool resource */
3326         dev->dtd_pool = dma_pool_create("langwell_dtd",
3327                         &dev->pdev->dev,
3328                         sizeof(struct langwell_dtd),
3329                         DTD_ALIGNMENT,
3330                         DMA_BOUNDARY);
3331
3332         if (!dev->dtd_pool)
3333                 return -ENOMEM;
3334
3335         /* restore PCI state */
3336         pci_restore_state(pdev);
3337
3338         /* enable IRQ handler */
3339         if (request_irq(pdev->irq, langwell_irq, IRQF_SHARED,
3340                                 driver_name, dev) != 0) {
3341                 dev_err(&dev->pdev->dev, "request interrupt %d failed\n",
3342                                 pdev->irq);
3343                 return -EBUSY;
3344         }
3345         dev->got_irq = 1;
3346
3347         /* reset and start controller to run state */
3348         if (dev->stopped) {
3349                 /* reset device controller */
3350                 langwell_udc_reset(dev);
3351
3352                 /* reset ep0 dQH and endptctrl */
3353                 ep0_reset(dev);
3354
3355                 /* start device if gadget is loaded */
3356                 if (dev->driver)
3357                         langwell_udc_start(dev);
3358         }
3359
3360         /* reset USB status */
3361         dev->usb_state = USB_STATE_ATTACHED;
3362         dev->ep0_state = WAIT_FOR_SETUP;
3363         dev->ep0_dir = USB_DIR_OUT;
3364
3365         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3366         return 0;
3367 }
3368
3369
3370 /* pci driver shutdown */
3371 static void langwell_udc_shutdown(struct pci_dev *pdev)
3372 {
3373         struct langwell_udc     *dev = pci_get_drvdata(pdev);
3374         u32                     usbmode;
3375
3376         dev_dbg(&dev->pdev->dev, "---> %s()\n", __func__);
3377
3378         /* reset controller mode to IDLE */
3379         usbmode = readl(&dev->op_regs->usbmode);
3380         dev_dbg(&dev->pdev->dev, "usbmode = 0x%08x\n", usbmode);
3381         usbmode &= (~3 | MODE_IDLE);
3382         writel(usbmode, &dev->op_regs->usbmode);
3383
3384         dev_dbg(&dev->pdev->dev, "<--- %s()\n", __func__);
3385 }
3386
3387 /*-------------------------------------------------------------------------*/
3388
3389 static const struct pci_device_id pci_ids[] = { {
3390         .class =        ((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
3391         .class_mask =   ~0,
3392         .vendor =       0x8086,
3393         .device =       0x0811,
3394         .subvendor =    PCI_ANY_ID,
3395         .subdevice =    PCI_ANY_ID,
3396 }, { /* end: all zeroes */ }
3397 };
3398
3399 MODULE_DEVICE_TABLE(pci, pci_ids);
3400
3401
3402 static struct pci_driver langwell_pci_driver = {
3403         .name =         (char *) driver_name,
3404         .id_table =     pci_ids,
3405
3406         .probe =        langwell_udc_probe,
3407         .remove =       langwell_udc_remove,
3408
3409         /* device controller suspend/resume */
3410         .suspend =      langwell_udc_suspend,
3411         .resume =       langwell_udc_resume,
3412
3413         .shutdown =     langwell_udc_shutdown,
3414 };
3415
3416
3417 static int __init init(void)
3418 {
3419         return pci_register_driver(&langwell_pci_driver);
3420 }
3421 module_init(init);
3422
3423
3424 static void __exit cleanup(void)
3425 {
3426         pci_unregister_driver(&langwell_pci_driver);
3427 }
3428 module_exit(cleanup);
3429
3430
3431 MODULE_DESCRIPTION(DRIVER_DESC);
3432 MODULE_AUTHOR("Xiaochen Shen <xiaochen.shen@intel.com>");
3433 MODULE_VERSION(DRIVER_VERSION);
3434 MODULE_LICENSE("GPL");
3435