drivers/usb/gadget/atmel_usba_udc.c

   1 /*
   2  * Driver for the Atmel USBA high speed USB device controller
   3  * [Original from Linux kernel: drivers/usb/gadget/atmel_usba_udc.c]
   4  *
   5  * Copyright (C) 2005-2013 Atmel Corporation
   6  *                         Bo Shen <voice.shen@atmel.com>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <asm/errno.h>
  13 #include <asm/gpio.h>
  14 #include <asm/hardware.h>
  15 #include <linux/list.h>
  16 #include <linux/usb/ch9.h>
  17 #include <linux/usb/gadget.h>
  18 #include <linux/usb/atmel_usba_udc.h>
  19 #include <malloc.h>
  20 #include <usb/lin_gadget_compat.h>
  21
  22 #include "atmel_usba_udc.h"
  23
  24 static int vbus_is_present(struct usba_udc *udc)
  25 {
  26         /* No Vbus detection: Assume always present */
  27         return 1;
  28 }
  29
  30 static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req)
  31 {
  32         unsigned int transaction_len;
  33
  34         transaction_len = req->req.length - req->req.actual;
  35         req->last_transaction = 1;
  36         if (transaction_len > ep->ep.maxpacket) {
  37                 transaction_len = ep->ep.maxpacket;
  38                 req->last_transaction = 0;
  39         } else if (transaction_len == ep->ep.maxpacket && req->req.zero) {
  40                         req->last_transaction = 0;
  41         }
  42
  43         DBG(DBG_QUEUE, "%s: submit_transaction, req %p (length %d)%s\n",
  44             ep->ep.name, req, transaction_len,
  45             req->last_transaction ? ", done" : "");
  46
  47         memcpy(ep->fifo, req->req.buf + req->req.actual, transaction_len);
  48         usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
  49         req->req.actual += transaction_len;
  50 }
  51
  52 static void submit_request(struct usba_ep *ep, struct usba_request *req)
  53 {
  54         DBG(DBG_QUEUE, "%s: submit_request: req %p (length %d), dma: %d\n",
  55             ep->ep.name, req, req->req.length, req->using_dma);
  56
  57         req->req.actual = 0;
  58         req->submitted = 1;
  59
  60         next_fifo_transaction(ep, req);
  61         if (req->last_transaction) {
  62                 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
  63                 usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
  64         } else {
  65                 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
  66                 usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
  67         }
  68 }
  69
  70 static void submit_next_request(struct usba_ep *ep)
  71 {
  72         struct usba_request *req;
  73
  74         if (list_empty(&ep->queue)) {
  75                 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY | USBA_RX_BK_RDY);
  76                 return;
  77         }
  78
  79         req = list_entry(ep->queue.next, struct usba_request, queue);
  80         if (!req->submitted)
  81                 submit_request(ep, req);
  82 }
  83
  84 static void send_status(struct usba_udc *udc, struct usba_ep *ep)
  85 {
  86         ep->state = STATUS_STAGE_IN;
  87         usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
  88         usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
  89 }
  90
  91 static void receive_data(struct usba_ep *ep)
  92 {
  93         struct usba_udc *udc = ep->udc;
  94         struct usba_request *req;
  95         unsigned long status;
  96         unsigned int bytecount, nr_busy;
  97         int is_complete = 0;
  98
  99         status = usba_ep_readl(ep, STA);
 100         nr_busy = USBA_BFEXT(BUSY_BANKS, status);
 101
 102         DBG(DBG_QUEUE, "receive data: nr_busy=%u\n", nr_busy);
 103
 104         while (nr_busy > 0) {
 105                 if (list_empty(&ep->queue)) {
 106                         usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
 107                         break;
 108                 }
 109                 req = list_entry(ep->queue.next,
 110                                  struct usba_request, queue);
 111
 112                 bytecount = USBA_BFEXT(BYTE_COUNT, status);
 113
 114                 if (status & USBA_SHORT_PACKET)
 115                         is_complete = 1;
 116                 if (req->req.actual + bytecount >= req->req.length) {
 117                         is_complete = 1;
 118                         bytecount = req->req.length - req->req.actual;
 119                 }
 120
 121                 memcpy(req->req.buf + req->req.actual, ep->fifo, bytecount);
 122                 req->req.actual += bytecount;
 123
 124                 usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
 125
 126                 if (is_complete) {
 127                         DBG(DBG_QUEUE, "%s: request done\n", ep->ep.name);
 128                         req->req.status = 0;
 129                         list_del_init(&req->queue);
 130                         usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
 131                         spin_lock(&udc->lock);
 132                         req->req.complete(&ep->ep, &req->req);
 133                         spin_unlock(&udc->lock);
 134                 }
 135
 136                 status = usba_ep_readl(ep, STA);
 137                 nr_busy = USBA_BFEXT(BUSY_BANKS, status);
 138
 139                 if (is_complete && ep_is_control(ep)) {
 140                         send_status(udc, ep);
 141                         break;
 142                 }
 143         }
 144 }
 145
 146 static void
 147 request_complete(struct usba_ep *ep, struct usba_request *req, int status)
 148 {
 149         if (req->req.status == -EINPROGRESS)
 150                 req->req.status = status;
 151
 152         DBG(DBG_GADGET | DBG_REQ, "%s: req %p complete: status %d, actual %u\n",
 153             ep->ep.name, req, req->req.status, req->req.actual);
 154
 155         req->req.complete(&ep->ep, &req->req);
 156 }
 157
 158 static void
 159 request_complete_list(struct usba_ep *ep, struct list_head *list, int status)
 160 {
 161         struct usba_request *req, *tmp_req;
 162
 163         list_for_each_entry_safe(req, tmp_req, list, queue) {
 164                 list_del_init(&req->queue);
 165                 request_complete(ep, req, status);
 166         }
 167 }
 168
 169 static int
 170 usba_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 171 {
 172         struct usba_ep *ep = to_usba_ep(_ep);
 173         struct usba_udc *udc = ep->udc;
 174         unsigned long flags = 0, ept_cfg, maxpacket;
 175         unsigned int nr_trans;
 176
 177         DBG(DBG_GADGET, "%s: ep_enable: desc=%p\n", ep->ep.name, desc);
 178
 179         maxpacket = usb_endpoint_maxp(desc) & 0x7ff;
 180
 181         if (((desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)
 182               != ep->index) ||
 183               ep->index == 0 ||
 184               desc->bDescriptorType != USB_DT_ENDPOINT ||
 185               maxpacket == 0 ||
 186               maxpacket > ep->fifo_size) {
 187                 DBG(DBG_ERR, "ep_enable: Invalid argument");
 188                 return -EINVAL;
 189         }
 190
 191         ep->is_isoc = 0;
 192         ep->is_in = 0;
 193
 194         if (maxpacket <= 8)
 195                 ept_cfg = USBA_BF(EPT_SIZE, USBA_EPT_SIZE_8);
 196         else
 197                 /* LSB is bit 1, not 0 */
 198                 ept_cfg = USBA_BF(EPT_SIZE, fls(maxpacket - 1) - 3);
 199
 200         DBG(DBG_HW, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n",
 201             ep->ep.name, ept_cfg, maxpacket);
 202
 203         if (usb_endpoint_dir_in(desc)) {
 204                 ep->is_in = 1;
 205                 ept_cfg |= USBA_EPT_DIR_IN;
 206         }
 207
 208         switch (usb_endpoint_type(desc)) {
 209         case USB_ENDPOINT_XFER_CONTROL:
 210                 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL);
 211                 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE);
 212                 break;
 213         case USB_ENDPOINT_XFER_ISOC:
 214                 if (!ep->can_isoc) {
 215                         DBG(DBG_ERR, "ep_enable: %s is not isoc capable\n",
 216                             ep->ep.name);
 217                         return -EINVAL;
 218                 }
 219
 220                 /*
 221                  * Bits 11:12 specify number of _additional_
 222                  * transactions per microframe.
 223                  */
 224                 nr_trans = ((usb_endpoint_maxp(desc) >> 11) & 3) + 1;
 225                 if (nr_trans > 3)
 226                         return -EINVAL;
 227
 228                 ep->is_isoc = 1;
 229                 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_ISO);
 230
 231                 /*
 232                  * Do triple-buffering on high-bandwidth iso endpoints.
 233                  */
 234                 if (nr_trans > 1 && ep->nr_banks == 3)
 235                         ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_TRIPLE);
 236                 else
 237                         ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE);
 238                 ept_cfg |= USBA_BF(NB_TRANS, nr_trans);
 239                 break;
 240         case USB_ENDPOINT_XFER_BULK:
 241                 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK);
 242                 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE);
 243                 break;
 244         case USB_ENDPOINT_XFER_INT:
 245                 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_INT);
 246                 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE);
 247                 break;
 248         }
 249
 250         spin_lock_irqsave(&ep->udc->lock, flags);
 251
 252         ep->desc = desc;
 253         ep->ep.maxpacket = maxpacket;
 254
 255         usba_ep_writel(ep, CFG, ept_cfg);
 256         usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
 257
 258         usba_writel(udc, INT_ENB,
 259                     (usba_readl(udc, INT_ENB)
 260                      | USBA_BF(EPT_INT, 1 << ep->index)));
 261
 262         spin_unlock_irqrestore(&udc->lock, flags);
 263
 264         DBG(DBG_HW, "EPT_CFG%d after init: %#08lx\n", ep->index,
 265             (unsigned long)usba_ep_readl(ep, CFG));
 266         DBG(DBG_HW, "INT_ENB after init: %#08lx\n",
 267             (unsigned long)usba_readl(udc, INT_ENB));
 268
 269         return 0;
 270 }
 271
 272 static int usba_ep_disable(struct usb_ep *_ep)
 273 {
 274         struct usba_ep *ep = to_usba_ep(_ep);
 275         struct usba_udc *udc = ep->udc;
 276         LIST_HEAD(req_list);
 277         unsigned long flags = 0;
 278
 279         DBG(DBG_GADGET, "ep_disable: %s\n", ep->ep.name);
 280
 281         spin_lock_irqsave(&udc->lock, flags);
 282
 283         if (!ep->desc) {
 284                 spin_unlock_irqrestore(&udc->lock, flags);
 285                 /* REVISIT because this driver disables endpoints in
 286                  * reset_all_endpoints() before calling disconnect(),
 287                  * most gadget drivers would trigger this non-error ...
 288                  */
 289                 if (udc->gadget.speed != USB_SPEED_UNKNOWN)
 290                         DBG(DBG_ERR, "ep_disable: %s not enabled\n",
 291                             ep->ep.name);
 292                 return -EINVAL;
 293         }
 294         ep->desc = NULL;
 295
 296         list_splice_init(&ep->queue, &req_list);
 297         usba_ep_writel(ep, CFG, 0);
 298         usba_ep_writel(ep, CTL_DIS, USBA_EPT_ENABLE);
 299         usba_writel(udc, INT_ENB,
 300                     usba_readl(udc, INT_ENB) &
 301                     ~USBA_BF(EPT_INT, 1 << ep->index));
 302
 303         request_complete_list(ep, &req_list, -ESHUTDOWN);
 304
 305         spin_unlock_irqrestore(&udc->lock, flags);
 306
 307         return 0;
 308 }
 309
 310 static struct usb_request *
 311 usba_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
 312 {
 313         struct usba_request *req;
 314
 315         DBG(DBG_GADGET, "ep_alloc_request: %p, 0x%x\n", _ep, gfp_flags);
 316
 317         req = calloc(1, sizeof(struct usba_request));
 318         if (!req)
 319                 return NULL;
 320
 321         INIT_LIST_HEAD(&req->queue);
 322
 323         return &req->req;
 324 }
 325
 326 static void
 327 usba_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
 328 {
 329         struct usba_request *req = to_usba_req(_req);
 330
 331         DBG(DBG_GADGET, "ep_free_request: %p, %p\n", _ep, _req);
 332
 333         free(req);
 334 }
 335
 336 static int
 337 usba_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 338 {
 339         struct usba_request *req = to_usba_req(_req);
 340         struct usba_ep *ep = to_usba_ep(_ep);
 341         struct usba_udc *udc = ep->udc;
 342         unsigned long flags = 0;
 343         int ret;
 344
 345         DBG(DBG_GADGET | DBG_QUEUE | DBG_REQ, "%s: queue req %p, len %u\n",
 346             ep->ep.name, req, _req->length);
 347
 348         if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN ||
 349             !ep->desc)
 350                 return -ESHUTDOWN;
 351
 352         req->submitted = 0;
 353         req->using_dma = 0;
 354         req->last_transaction = 0;
 355
 356         _req->status = -EINPROGRESS;
 357         _req->actual = 0;
 358
 359         /* May have received a reset since last time we checked */
 360         ret = -ESHUTDOWN;
 361         spin_lock_irqsave(&udc->lock, flags);
 362         if (ep->desc) {
 363                 list_add_tail(&req->queue, &ep->queue);
 364
 365                 if ((!ep_is_control(ep) && ep->is_in) ||
 366                     (ep_is_control(ep) && (ep->state == DATA_STAGE_IN ||
 367                     ep->state == STATUS_STAGE_IN)))
 368                         usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY);
 369                 else
 370                         usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY);
 371
 372                 ret = 0;
 373         }
 374         spin_unlock_irqrestore(&udc->lock, flags);
 375
 376         return ret;
 377 }
 378
 379 static int usba_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 380 {
 381         struct usba_ep *ep = to_usba_ep(_ep);
 382         struct usba_request *req = to_usba_req(_req);
 383
 384         DBG(DBG_GADGET | DBG_QUEUE, "ep_dequeue: %s, req %p\n",
 385             ep->ep.name, req);
 386
 387         /*
 388          * Errors should stop the queue from advancing until the
 389          * completion function returns.
 390          */
 391         list_del_init(&req->queue);
 392
 393         request_complete(ep, req, -ECONNRESET);
 394
 395         /* Process the next request if any */
 396         submit_next_request(ep);
 397
 398         return 0;
 399 }
 400
 401 static int usba_ep_set_halt(struct usb_ep *_ep, int value)
 402 {
 403         struct usba_ep *ep = to_usba_ep(_ep);
 404         unsigned long flags = 0;
 405         int ret = 0;
 406
 407         DBG(DBG_GADGET, "endpoint %s: %s HALT\n", ep->ep.name,
 408             value ? "set" : "clear");
 409
 410         if (!ep->desc) {
 411                 DBG(DBG_ERR, "Attempted to halt uninitialized ep %s\n",
 412                     ep->ep.name);
 413                 return -ENODEV;
 414         }
 415
 416         if (ep->is_isoc) {
 417                 DBG(DBG_ERR, "Attempted to halt isochronous ep %s\n",
 418                     ep->ep.name);
 419                 return -ENOTTY;
 420         }
 421
 422         spin_lock_irqsave(&udc->lock, flags);
 423
 424         /*
 425          * We can't halt IN endpoints while there are still data to be
 426          * transferred
 427          */
 428         if (!list_empty(&ep->queue) ||
 429             ((value && ep->is_in && (usba_ep_readl(ep, STA) &
 430             USBA_BF(BUSY_BANKS, -1L))))) {
 431                 ret = -EAGAIN;
 432         } else {
 433                 if (value)
 434                         usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL);
 435                 else
 436                         usba_ep_writel(ep, CLR_STA,
 437                                        USBA_FORCE_STALL | USBA_TOGGLE_CLR);
 438                 usba_ep_readl(ep, STA);
 439         }
 440
 441         spin_unlock_irqrestore(&udc->lock, flags);
 442
 443         return ret;
 444 }
 445
 446 static int usba_ep_fifo_status(struct usb_ep *_ep)
 447 {
 448         struct usba_ep *ep = to_usba_ep(_ep);
 449
 450         return USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA));
 451 }
 452
 453 static void usba_ep_fifo_flush(struct usb_ep *_ep)
 454 {
 455         struct usba_ep *ep = to_usba_ep(_ep);
 456         struct usba_udc *udc = ep->udc;
 457
 458         usba_writel(udc, EPT_RST, 1 << ep->index);
 459 }
 460
 461 static const struct usb_ep_ops usba_ep_ops = {
 462         .enable         = usba_ep_enable,
 463         .disable        = usba_ep_disable,
 464         .alloc_request  = usba_ep_alloc_request,
 465         .free_request   = usba_ep_free_request,
 466         .queue          = usba_ep_queue,
 467         .dequeue        = usba_ep_dequeue,
 468         .set_halt       = usba_ep_set_halt,
 469         .fifo_status    = usba_ep_fifo_status,
 470         .fifo_flush     = usba_ep_fifo_flush,
 471 };
 472
 473 static int usba_udc_get_frame(struct usb_gadget *gadget)
 474 {
 475         struct usba_udc *udc = to_usba_udc(gadget);
 476
 477         return USBA_BFEXT(FRAME_NUMBER, usba_readl(udc, FNUM));
 478 }
 479
 480 static int usba_udc_wakeup(struct usb_gadget *gadget)
 481 {
 482         struct usba_udc *udc = to_usba_udc(gadget);
 483         unsigned long flags = 0;
 484         u32 ctrl;
 485         int ret = -EINVAL;
 486
 487         spin_lock_irqsave(&udc->lock, flags);
 488         if (udc->devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
 489                 ctrl = usba_readl(udc, CTRL);
 490                 usba_writel(udc, CTRL, ctrl | USBA_REMOTE_WAKE_UP);
 491                 ret = 0;
 492         }
 493         spin_unlock_irqrestore(&udc->lock, flags);
 494
 495         return ret;
 496 }
 497
 498 static int
 499 usba_udc_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered)
 500 {
 501         struct usba_udc *udc = to_usba_udc(gadget);
 502         unsigned long flags = 0;
 503
 504         spin_lock_irqsave(&udc->lock, flags);
 505         if (is_selfpowered)
 506                 udc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
 507         else
 508                 udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
 509         spin_unlock_irqrestore(&udc->lock, flags);
 510
 511         return 0;
 512 }
 513
 514 static const struct usb_gadget_ops usba_udc_ops = {
 515         .get_frame              = usba_udc_get_frame,
 516         .wakeup                 = usba_udc_wakeup,
 517         .set_selfpowered        = usba_udc_set_selfpowered,
 518 };
 519
 520 static struct usb_endpoint_descriptor usba_ep0_desc = {
 521         .bLength = USB_DT_ENDPOINT_SIZE,
 522         .bDescriptorType = USB_DT_ENDPOINT,
 523         .bEndpointAddress = 0,
 524         .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
 525         .wMaxPacketSize = cpu_to_le16(64),
 526         /* FIXME: I have no idea what to put here */
 527         .bInterval = 1,
 528 };
 529
 530 /*
 531  * Called with interrupts disabled and udc->lock held.
 532  */
 533 static void reset_all_endpoints(struct usba_udc *udc)
 534 {
 535         struct usba_ep *ep;
 536         struct usba_request *req, *tmp_req;
 537
 538         usba_writel(udc, EPT_RST, ~0UL);
 539
 540         ep = to_usba_ep(udc->gadget.ep0);
 541         list_for_each_entry_safe(req, tmp_req, &ep->queue, queue) {
 542                 list_del_init(&req->queue);
 543                 request_complete(ep, req, -ECONNRESET);
 544         }
 545
 546         /* NOTE:  normally, the next call to the gadget driver is in
 547          * charge of disabling endpoints... usually disconnect().
 548          * The exception would be entering a high speed test mode.
 549          *
 550          * FIXME remove this code ... and retest thoroughly.
 551          */
 552         list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
 553                 if (ep->desc) {
 554                         spin_unlock(&udc->lock);
 555                         usba_ep_disable(&ep->ep);
 556                         spin_lock(&udc->lock);
 557                 }
 558         }
 559 }
 560
 561 static struct usba_ep *get_ep_by_addr(struct usba_udc *udc, u16 wIndex)
 562 {
 563         struct usba_ep *ep;
 564
 565         if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
 566                 return to_usba_ep(udc->gadget.ep0);
 567
 568         list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
 569                 u8 bEndpointAddress;
 570
 571                 if (!ep->desc)
 572                         continue;
 573                 bEndpointAddress = ep->desc->bEndpointAddress;
 574                 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
 575                         continue;
 576                 if ((bEndpointAddress & USB_ENDPOINT_NUMBER_MASK)
 577                                 == (wIndex & USB_ENDPOINT_NUMBER_MASK))
 578                         return ep;
 579         }
 580
 581         return NULL;
 582 }
 583
 584 /* Called with interrupts disabled and udc->lock held */
 585 static inline void set_protocol_stall(struct usba_udc *udc, struct usba_ep *ep)
 586 {
 587         usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL);
 588         ep->state = WAIT_FOR_SETUP;
 589 }
 590
 591 static inline int is_stalled(struct usba_udc *udc, struct usba_ep *ep)
 592 {
 593         if (usba_ep_readl(ep, STA) & USBA_FORCE_STALL)
 594                 return 1;
 595         return 0;
 596 }
 597
 598 static inline void set_address(struct usba_udc *udc, unsigned int addr)
 599 {
 600         u32 regval;
 601
 602         DBG(DBG_BUS, "setting address %u...\n", addr);
 603         regval = usba_readl(udc, CTRL);
 604         regval = USBA_BFINS(DEV_ADDR, addr, regval);
 605         usba_writel(udc, CTRL, regval);
 606 }
 607
 608 static int do_test_mode(struct usba_udc *udc)
 609 {
 610         static const char test_packet_buffer[] = {
 611                 /* JKJKJKJK * 9 */
 612                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 613                 /* JJKKJJKK * 8 */
 614                 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
 615                 /* JJKKJJKK * 8 */
 616                 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,
 617                 /* JJJJJJJKKKKKKK * 8 */
 618                 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 619                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 620                 /* JJJJJJJK * 8 */
 621                 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD,
 622                 /* {JKKKKKKK * 10}, JK */
 623                 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E
 624         };
 625         struct usba_ep *ep;
 626         int test_mode;
 627
 628         test_mode = udc->test_mode;
 629
 630         /* Start from a clean slate */
 631         reset_all_endpoints(udc);
 632
 633         switch (test_mode) {
 634         case 0x0100:
 635                 /* Test_J */
 636                 usba_writel(udc, TST, USBA_TST_J_MODE);
 637                 DBG(DBG_ALL, "Entering Test_J mode...\n");
 638                 break;
 639         case 0x0200:
 640                 /* Test_K */
 641                 usba_writel(udc, TST, USBA_TST_K_MODE);
 642                 DBG(DBG_ALL, "Entering Test_K mode...\n");
 643                 break;
 644         case 0x0300:
 645                 /*
 646                  * Test_SE0_NAK: Force high-speed mode and set up ep0
 647                  * for Bulk IN transfers
 648                  */
 649                 ep = &udc->usba_ep[0];
 650                 usba_writel(udc, TST,
 651                             USBA_BF(SPEED_CFG, USBA_SPEED_CFG_FORCE_HIGH));
 652                 usba_ep_writel(ep, CFG,
 653                                USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64)
 654                                | USBA_EPT_DIR_IN
 655                                | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK)
 656                                | USBA_BF(BK_NUMBER, 1));
 657                 if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) {
 658                         set_protocol_stall(udc, ep);
 659                         DBG(DBG_ALL, "Test_SE0_NAK: ep0 not mapped\n");
 660                 } else {
 661                         usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
 662                         DBG(DBG_ALL, "Entering Test_SE0_NAK mode...\n");
 663                 }
 664                 break;
 665         case 0x0400:
 666                 /* Test_Packet */
 667                 ep = &udc->usba_ep[0];
 668                 usba_ep_writel(ep, CFG,
 669                                USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64)
 670                                | USBA_EPT_DIR_IN
 671                                | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK)
 672                                | USBA_BF(BK_NUMBER, 1));
 673                 if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) {
 674                         set_protocol_stall(udc, ep);
 675                         DBG(DBG_ALL, "Test_Packet: ep0 not mapped\n");
 676                 } else {
 677                         usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
 678                         usba_writel(udc, TST, USBA_TST_PKT_MODE);
 679                         memcpy(ep->fifo, test_packet_buffer,
 680                                sizeof(test_packet_buffer));
 681                         usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
 682                         DBG(DBG_ALL, "Entering Test_Packet mode...\n");
 683                 }
 684                 break;
 685         default:
 686                 DBG(DBG_ERR, "Invalid test mode: 0x%04x\n", test_mode);
 687                 return -EINVAL;
 688         }
 689
 690         return 0;
 691 }
 692
 693 /* Avoid overly long expressions */
 694 static inline bool feature_is_dev_remote_wakeup(struct usb_ctrlrequest *crq)
 695 {
 696         if (crq->wValue == cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP))
 697                 return true;
 698         return false;
 699 }
 700
 701 static inline bool feature_is_dev_test_mode(struct usb_ctrlrequest *crq)
 702 {
 703         if (crq->wValue == cpu_to_le16(USB_DEVICE_TEST_MODE))
 704                 return true;
 705         return false;
 706 }
 707
 708 static inline bool feature_is_ep_halt(struct usb_ctrlrequest *crq)
 709 {
 710         if (crq->wValue == cpu_to_le16(USB_ENDPOINT_HALT))
 711                 return true;
 712         return false;
 713 }
 714
 715 static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep,
 716                 struct usb_ctrlrequest *crq)
 717 {
 718         int retval = 0;
 719
 720         switch (crq->bRequest) {
 721         case USB_REQ_GET_STATUS: {
 722                 u16 status;
 723
 724                 if (crq->bRequestType == (USB_DIR_IN | USB_RECIP_DEVICE)) {
 725                         status = cpu_to_le16(udc->devstatus);
 726                 } else if (crq->bRequestType
 727                                 == (USB_DIR_IN | USB_RECIP_INTERFACE)) {
 728                         status = cpu_to_le16(0);
 729                 } else if (crq->bRequestType
 730                                 == (USB_DIR_IN | USB_RECIP_ENDPOINT)) {
 731                         struct usba_ep *target;
 732
 733                         target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
 734                         if (!target)
 735                                 goto stall;
 736
 737                         status = 0;
 738                         if (is_stalled(udc, target))
 739                                 status |= cpu_to_le16(1);
 740                 } else {
 741                         goto delegate;
 742                 }
 743
 744                 /* Write directly to the FIFO. No queueing is done. */
 745                 if (crq->wLength != cpu_to_le16(sizeof(status)))
 746                         goto stall;
 747                 ep->state = DATA_STAGE_IN;
 748                 __raw_writew(status, ep->fifo);
 749                 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
 750                 break;
 751         }
 752
 753         case USB_REQ_CLEAR_FEATURE: {
 754                 if (crq->bRequestType == USB_RECIP_DEVICE) {
 755                         if (feature_is_dev_remote_wakeup(crq))
 756                                 udc->devstatus
 757                                         &= ~(1 << USB_DEVICE_REMOTE_WAKEUP);
 758                         else
 759                                 /* Can't CLEAR_FEATURE TEST_MODE */
 760                                 goto stall;
 761                 } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
 762                         struct usba_ep *target;
 763
 764                         if (crq->wLength != cpu_to_le16(0) ||
 765                             !feature_is_ep_halt(crq))
 766                                 goto stall;
 767                         target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
 768                         if (!target)
 769                                 goto stall;
 770
 771                         usba_ep_writel(target, CLR_STA, USBA_FORCE_STALL);
 772                         if (target->index != 0)
 773                                 usba_ep_writel(target, CLR_STA,
 774                                                USBA_TOGGLE_CLR);
 775                 } else {
 776                         goto delegate;
 777                 }
 778
 779                 send_status(udc, ep);
 780                 break;
 781         }
 782
 783         case USB_REQ_SET_FEATURE: {
 784                 if (crq->bRequestType == USB_RECIP_DEVICE) {
 785                         if (feature_is_dev_test_mode(crq)) {
 786                                 send_status(udc, ep);
 787                                 ep->state = STATUS_STAGE_TEST;
 788                                 udc->test_mode = le16_to_cpu(crq->wIndex);
 789                                 return 0;
 790                         } else if (feature_is_dev_remote_wakeup(crq)) {
 791                                 udc->devstatus |= 1 << USB_DEVICE_REMOTE_WAKEUP;
 792                         } else {
 793                                 goto stall;
 794                         }
 795                 } else if (crq->bRequestType == USB_RECIP_ENDPOINT) {
 796                         struct usba_ep *target;
 797
 798                         if (crq->wLength != cpu_to_le16(0) ||
 799                             !feature_is_ep_halt(crq))
 800                                 goto stall;
 801
 802                         target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex));
 803                         if (!target)
 804                                 goto stall;
 805
 806                         usba_ep_writel(target, SET_STA, USBA_FORCE_STALL);
 807                 } else {
 808                         goto delegate;
 809                 }
 810
 811                 send_status(udc, ep);
 812                 break;
 813         }
 814
 815         case USB_REQ_SET_ADDRESS:
 816                 if (crq->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE))
 817                         goto delegate;
 818
 819                 set_address(udc, le16_to_cpu(crq->wValue));
 820                 send_status(udc, ep);
 821                 ep->state = STATUS_STAGE_ADDR;
 822                 break;
 823
 824         default:
 825 delegate:
 826                 spin_unlock(&udc->lock);
 827                 retval = udc->driver->setup(&udc->gadget, crq);
 828                 spin_lock(&udc->lock);
 829         }
 830
 831         return retval;
 832
 833 stall:
 834         DBG(DBG_ALL, "%s: Invalid setup request: %02x.%02x v%04x i%04x l%d\n",
 835             ep->ep.name, crq->bRequestType, crq->bRequest,
 836             le16_to_cpu(crq->wValue), le16_to_cpu(crq->wIndex),
 837             le16_to_cpu(crq->wLength));
 838         set_protocol_stall(udc, ep);
 839
 840         return -1;
 841 }
 842
 843 static void usba_control_irq(struct usba_udc *udc, struct usba_ep *ep)
 844 {
 845         struct usba_request *req;
 846         u32 epstatus;
 847         u32 epctrl;
 848
 849 restart:
 850         epstatus = usba_ep_readl(ep, STA);
 851         epctrl = usba_ep_readl(ep, CTL);
 852
 853         DBG(DBG_INT, "%s [%d]: s/%08x c/%08x\n",
 854             ep->ep.name, ep->state, epstatus, epctrl);
 855
 856         req = NULL;
 857         if (!list_empty(&ep->queue))
 858                 req = list_entry(ep->queue.next,
 859                                  struct usba_request, queue);
 860
 861         if ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) {
 862                 if (req->submitted)
 863                         next_fifo_transaction(ep, req);
 864                 else
 865                         submit_request(ep, req);
 866
 867                 if (req->last_transaction) {
 868                         usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
 869                         usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE);
 870                 }
 871                 goto restart;
 872         }
 873         if ((epstatus & epctrl) & USBA_TX_COMPLETE) {
 874                 usba_ep_writel(ep, CLR_STA, USBA_TX_COMPLETE);
 875
 876                 switch (ep->state) {
 877                 case DATA_STAGE_IN:
 878                         usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY);
 879                         usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
 880                         ep->state = STATUS_STAGE_OUT;
 881                         break;
 882                 case STATUS_STAGE_ADDR:
 883                         /* Activate our new address */
 884                         usba_writel(udc, CTRL, (usba_readl(udc, CTRL)
 885                                                 | USBA_FADDR_EN));
 886                         usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
 887                         ep->state = WAIT_FOR_SETUP;
 888                         break;
 889                 case STATUS_STAGE_IN:
 890                         if (req) {
 891                                 list_del_init(&req->queue);
 892                                 request_complete(ep, req, 0);
 893                                 submit_next_request(ep);
 894                         }
 895                         usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
 896                         ep->state = WAIT_FOR_SETUP;
 897                         break;
 898                 case STATUS_STAGE_TEST:
 899                         usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE);
 900                         ep->state = WAIT_FOR_SETUP;
 901                         if (do_test_mode(udc))
 902                                 set_protocol_stall(udc, ep);
 903                         break;
 904                 default:
 905                         DBG(DBG_ALL, "%s: TXCOMP: Invalid endpoint state %d\n",
 906                             ep->ep.name, ep->state);
 907                         set_protocol_stall(udc, ep);
 908                         break;
 909                 }
 910
 911                 goto restart;
 912         }
 913         if ((epstatus & epctrl) & USBA_RX_BK_RDY) {
 914                 switch (ep->state) {
 915                 case STATUS_STAGE_OUT:
 916                         usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
 917                         usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
 918
 919                         if (req) {
 920                                 list_del_init(&req->queue);
 921                                 request_complete(ep, req, 0);
 922                         }
 923                         ep->state = WAIT_FOR_SETUP;
 924                         break;
 925
 926                 case DATA_STAGE_OUT:
 927                         receive_data(ep);
 928                         break;
 929
 930                 default:
 931                         usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY);
 932                         usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
 933                         DBG(DBG_ALL, "%s: RXRDY: Invalid endpoint state %d\n",
 934                             ep->ep.name, ep->state);
 935                         set_protocol_stall(udc, ep);
 936                         break;
 937                 }
 938
 939                 goto restart;
 940         }
 941         if (epstatus & USBA_RX_SETUP) {
 942                 union {
 943                         struct usb_ctrlrequest crq;
 944                         unsigned long data[2];
 945                 } crq;
 946                 unsigned int pkt_len;
 947                 int ret;
 948
 949                 if (ep->state != WAIT_FOR_SETUP) {
 950                         /*
 951                          * Didn't expect a SETUP packet at this
 952                          * point. Clean up any pending requests (which
 953                          * may be successful).
 954                          */
 955                         int status = -EPROTO;
 956
 957                         /*
 958                          * RXRDY and TXCOMP are dropped when SETUP
 959                          * packets arrive.  Just pretend we received
 960                          * the status packet.
 961                          */
 962                         if (ep->state == STATUS_STAGE_OUT ||
 963                             ep->state == STATUS_STAGE_IN) {
 964                                 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
 965                                 status = 0;
 966                         }
 967
 968                         if (req) {
 969                                 list_del_init(&req->queue);
 970                                 request_complete(ep, req, status);
 971                         }
 972                 }
 973
 974                 pkt_len = USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA));
 975                 DBG(DBG_HW, "Packet length: %u\n", pkt_len);
 976                 if (pkt_len != sizeof(crq)) {
 977                         DBG(DBG_ALL, "udc: Invalid length %u (expected %zu)\n",
 978                             pkt_len, sizeof(crq));
 979                         set_protocol_stall(udc, ep);
 980                         return;
 981                 }
 982
 983                 DBG(DBG_FIFO, "Copying ctrl request from 0x%p:\n", ep->fifo);
 984                 memcpy(crq.data, ep->fifo, sizeof(crq));
 985
 986                 /* Free up one bank in the FIFO so that we can
 987                  * generate or receive a reply right away. */
 988                 usba_ep_writel(ep, CLR_STA, USBA_RX_SETUP);
 989
 990                 if (crq.crq.bRequestType & USB_DIR_IN) {
 991                         /*
 992                          * The USB 2.0 spec states that "if wLength is
 993                          * zero, there is no data transfer phase."
 994                          * However, testusb #14 seems to actually
 995                          * expect a data phase even if wLength = 0...
 996                          */
 997                         ep->state = DATA_STAGE_IN;
 998                 } else {
 999                         if (crq.crq.wLength != cpu_to_le16(0))
1000                                 ep->state = DATA_STAGE_OUT;
1001                         else
1002                                 ep->state = STATUS_STAGE_IN;
1003                 }
1004
1005                 ret = -1;
1006                 if (ep->index == 0) {
1007                         ret = handle_ep0_setup(udc, ep, &crq.crq);
1008                 } else {
1009                         spin_unlock(&udc->lock);
1010                         ret = udc->driver->setup(&udc->gadget, &crq.crq);
1011                         spin_lock(&udc->lock);
1012                 }
1013
1014                 DBG(DBG_BUS, "req %02x.%02x, length %d, state %d, ret %d\n",
1015                     crq.crq.bRequestType, crq.crq.bRequest,
1016                     le16_to_cpu(crq.crq.wLength), ep->state, ret);
1017
1018                 if (ret < 0) {
1019                         /* Let the host know that we failed */
1020                         set_protocol_stall(udc, ep);
1021                 }
1022         }
1023 }
1024
1025 static void usba_ep_irq(struct usba_udc *udc, struct usba_ep *ep)
1026 {
1027         struct usba_request *req;
1028         u32 epstatus;
1029         u32 epctrl;
1030
1031         epstatus = usba_ep_readl(ep, STA);
1032         epctrl = usba_ep_readl(ep, CTL);
1033
1034         DBG(DBG_INT, "%s: interrupt, status: 0x%08x\n", ep->ep.name, epstatus);
1035
1036         while ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) {
1037                 DBG(DBG_BUS, "%s: TX PK ready\n", ep->ep.name);
1038
1039                 if (list_empty(&ep->queue)) {
1040                         DBG(DBG_INT, "ep_irq: queue empty\n");
1041                         usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY);
1042                         return;
1043                 }
1044
1045                 req = list_entry(ep->queue.next, struct usba_request, queue);
1046
1047                 if (req->submitted)
1048                         next_fifo_transaction(ep, req);
1049                 else
1050                         submit_request(ep, req);
1051
1052                 if (req->last_transaction) {
1053                         list_del_init(&req->queue);
1054                         submit_next_request(ep);
1055                         request_complete(ep, req, 0);
1056                 }
1057
1058                 epstatus = usba_ep_readl(ep, STA);
1059                 epctrl = usba_ep_readl(ep, CTL);
1060         }
1061
1062         if ((epstatus & epctrl) & USBA_RX_BK_RDY) {
1063                 DBG(DBG_BUS, "%s: RX data ready\n", ep->ep.name);
1064                 receive_data(ep);
1065         }
1066 }
1067
1068 static int usba_udc_irq(struct usba_udc *udc)
1069 {
1070         u32 status, ep_status;
1071
1072         spin_lock(&udc->lock);
1073
1074         status = usba_readl(udc, INT_STA);
1075         DBG(DBG_INT, "irq, status=%#08x\n", status);
1076
1077         if (status & USBA_DET_SUSPEND) {
1078                 usba_writel(udc, INT_CLR, USBA_DET_SUSPEND);
1079                 DBG(DBG_BUS, "Suspend detected\n");
1080                 if (udc->gadget.speed != USB_SPEED_UNKNOWN &&
1081                     udc->driver && udc->driver->suspend) {
1082                         spin_unlock(&udc->lock);
1083                         udc->driver->suspend(&udc->gadget);
1084                         spin_lock(&udc->lock);
1085                 }
1086         }
1087
1088         if (status & USBA_WAKE_UP) {
1089                 usba_writel(udc, INT_CLR, USBA_WAKE_UP);
1090                 DBG(DBG_BUS, "Wake Up CPU detected\n");
1091         }
1092
1093         if (status & USBA_END_OF_RESUME) {
1094                 usba_writel(udc, INT_CLR, USBA_END_OF_RESUME);
1095                 DBG(DBG_BUS, "Resume detected\n");
1096                 if (udc->gadget.speed != USB_SPEED_UNKNOWN &&
1097                     udc->driver && udc->driver->resume) {
1098                         spin_unlock(&udc->lock);
1099                         udc->driver->resume(&udc->gadget);
1100                         spin_lock(&udc->lock);
1101                 }
1102         }
1103
1104         ep_status = USBA_BFEXT(EPT_INT, status);
1105         if (ep_status) {
1106                 int i;
1107
1108                 for (i = 0; i < USBA_NR_ENDPOINTS; i++)
1109                         if (ep_status & (1 << i)) {
1110                                 if (ep_is_control(&udc->usba_ep[i]))
1111                                         usba_control_irq(udc, &udc->usba_ep[i]);
1112                                 else
1113                                         usba_ep_irq(udc, &udc->usba_ep[i]);
1114                         }
1115         }
1116
1117         if (status & USBA_END_OF_RESET) {
1118                 struct usba_ep *ep0;
1119
1120                 usba_writel(udc, INT_CLR, USBA_END_OF_RESET);
1121                 reset_all_endpoints(udc);
1122
1123                 if (udc->gadget.speed != USB_SPEED_UNKNOWN &&
1124                     udc->driver->disconnect) {
1125                         udc->gadget.speed = USB_SPEED_UNKNOWN;
1126                         spin_unlock(&udc->lock);
1127                         udc->driver->disconnect(&udc->gadget);
1128                         spin_lock(&udc->lock);
1129                 }
1130
1131                 if (status & USBA_HIGH_SPEED)
1132                         udc->gadget.speed = USB_SPEED_HIGH;
1133                 else
1134                         udc->gadget.speed = USB_SPEED_FULL;
1135
1136                 ep0 = &udc->usba_ep[0];
1137                 ep0->desc = &usba_ep0_desc;
1138                 ep0->state = WAIT_FOR_SETUP;
1139                 usba_ep_writel(ep0, CFG,
1140                                (USBA_BF(EPT_SIZE, EP0_EPT_SIZE)
1141                                 | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL)
1142                                 | USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE)));
1143                 usba_ep_writel(ep0, CTL_ENB,
1144                                USBA_EPT_ENABLE | USBA_RX_SETUP);
1145                 usba_writel(udc, INT_ENB,
1146                             (usba_readl(udc, INT_ENB)
1147                              | USBA_BF(EPT_INT, 1)
1148                              | USBA_DET_SUSPEND
1149                              | USBA_END_OF_RESUME));
1150
1151                 /*
1152                  * Unclear why we hit this irregularly, e.g. in usbtest,
1153                  * but it's clearly harmless...
1154                  */
1155                 if (!(usba_ep_readl(ep0, CFG) & USBA_EPT_MAPPED))
1156                         DBG(DBG_ALL, "ODD: EP0 configuration is invalid!\n");
1157         }
1158
1159         spin_unlock(&udc->lock);
1160
1161         return 0;
1162 }
1163
1164 static int atmel_usba_start(struct usba_udc *udc)
1165 {
1166         udc->devstatus = 1 << USB_DEVICE_SELF_POWERED;
1167
1168         udc->vbus_prev = 0;
1169
1170         /* If Vbus is present, enable the controller and wait for reset */
1171         if (vbus_is_present(udc) && udc->vbus_prev == 0) {
1172                 usba_writel(udc, CTRL, USBA_ENABLE_MASK);
1173                 usba_writel(udc, INT_ENB, USBA_END_OF_RESET);
1174         }
1175
1176         return 0;
1177 }
1178
1179 static int atmel_usba_stop(struct usba_udc *udc)
1180 {
1181         udc->gadget.speed = USB_SPEED_UNKNOWN;
1182         reset_all_endpoints(udc);
1183
1184         /* This will also disable the DP pullup */
1185         usba_writel(udc, CTRL, USBA_DISABLE_MASK);
1186
1187         return 0;
1188 }
1189
1190 static struct usba_udc controller = {
1191         .regs = (unsigned *)ATMEL_BASE_UDPHS,
1192         .fifo = (unsigned *)ATMEL_BASE_UDPHS_FIFO,
1193         .gadget = {
1194                 .ops            = &usba_udc_ops,
1195                 .ep_list        = LIST_HEAD_INIT(controller.gadget.ep_list),
1196                 .speed          = USB_SPEED_HIGH,
1197                 .is_dualspeed   = 1,
1198                 .name           = "atmel_usba_udc",
1199         },
1200 };
1201
1202 int usb_gadget_handle_interrupts(void)
1203 {
1204         struct usba_udc *udc = &controller;
1205
1206         return usba_udc_irq(udc);
1207 }
1208
1209
1210 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1211 {
1212         struct usba_udc *udc = &controller;
1213         int ret;
1214
1215         if (!driver || !driver->bind || !driver->setup) {
1216                 printf("bad paramter\n");
1217                 return -EINVAL;
1218         }
1219
1220         if (udc->driver) {
1221                 printf("UDC already has a gadget driver\n");
1222                 return -EBUSY;
1223         }
1224
1225         atmel_usba_start(udc);
1226
1227         udc->driver = driver;
1228
1229         ret = driver->bind(&udc->gadget);
1230         if (ret) {
1231                 error("driver->bind() returned %d\n", ret);
1232                 udc->driver = NULL;
1233         }
1234
1235         return ret;
1236 }
1237
1238 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1239 {
1240         struct usba_udc *udc = &controller;
1241
1242         if (!driver || !driver->unbind || !driver->disconnect) {
1243                 error("bad paramter\n");
1244                 return -EINVAL;
1245         }
1246
1247         driver->disconnect(&udc->gadget);
1248         driver->unbind(&udc->gadget);
1249         udc->driver = NULL;
1250
1251         atmel_usba_stop(udc);
1252
1253         return 0;
1254 }
1255
1256 static struct usba_ep *usba_udc_pdata(struct usba_platform_data *pdata,
1257                                       struct usba_udc *udc)
1258 {
1259         struct usba_ep *eps;
1260         int i;
1261
1262         eps = malloc(sizeof(struct usba_ep) * pdata->num_ep);
1263         if (!eps) {
1264                 error("failed to alloc eps\n");
1265                 return NULL;
1266         }
1267
1268         udc->gadget.ep0 = &eps[0].ep;
1269
1270         INIT_LIST_HEAD(&udc->gadget.ep_list);
1271         INIT_LIST_HEAD(&eps[0].ep.ep_list);
1272
1273         for (i = 0; i < pdata->num_ep; i++) {
1274                 struct usba_ep *ep = &eps[i];
1275
1276                 ep->ep_regs = udc->regs + USBA_EPT_BASE(i);
1277                 ep->dma_regs = udc->regs + USBA_DMA_BASE(i);
1278                 ep->fifo = udc->fifo + USBA_FIFO_BASE(i);
1279                 ep->ep.ops = &usba_ep_ops;
1280                 ep->ep.name = pdata->ep[i].name;
1281                 ep->ep.maxpacket = pdata->ep[i].fifo_size;
1282                 ep->fifo_size = ep->ep.maxpacket;
1283                 ep->udc = udc;
1284                 INIT_LIST_HEAD(&ep->queue);
1285                 ep->nr_banks = pdata->ep[i].nr_banks;
1286                 ep->index = pdata->ep[i].index;
1287                 ep->can_dma = pdata->ep[i].can_dma;
1288                 ep->can_isoc = pdata->ep[i].can_isoc;
1289                 if (i)
1290                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
1291         };
1292
1293         return eps;
1294 }
1295
1296 int usba_udc_probe(struct usba_platform_data *pdata)
1297 {
1298         struct usba_udc *udc;
1299
1300         udc = &controller;
1301
1302         udc->usba_ep = usba_udc_pdata(pdata, udc);
1303
1304         return 0;
1305 }