drivers/usb/musb/musb_gadget.c

   1 /*
   2  * MUSB OTG driver peripheral support
   3  *
   4  * Copyright 2005 Mentor Graphics Corporation
   5  * Copyright (C) 2005-2006 by Texas Instruments
   6  * Copyright (C) 2006-2007 Nokia Corporation
   7  * Copyright (C) 2009 MontaVista Software, Inc. <source@mvista.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * version 2 as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  26  * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  29  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  30  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  */
  35
  36 #include <linux/kernel.h>
  37 #include <linux/list.h>
  38 #include <linux/timer.h>
  39 #include <linux/module.h>
  40 #include <linux/smp.h>
  41 #include <linux/spinlock.h>
  42 #include <linux/delay.h>
  43 #include <linux/dma-mapping.h>
  44 #include <linux/slab.h>
  45
  46 #include "musb_core.h"
  47
  48
  49 /* ----------------------------------------------------------------------- */
  50
  51 #define is_buffer_mapped(req) (is_dma_capable() && \
  52                                         (req->map_state != UN_MAPPED))
  53
  54 /* Maps the buffer to dma  */
  55
  56 static inline void map_dma_buffer(struct musb_request *request,
  57                         struct musb *musb, struct musb_ep *musb_ep)
  58 {
  59         int compatible = true;
  60         struct dma_controller *dma = musb->dma_controller;
  61
  62         request->map_state = UN_MAPPED;
  63
  64         if (!is_dma_capable() || !musb_ep->dma)
  65                 return;
  66
  67         /* Check if DMA engine can handle this request.
  68          * DMA code must reject the USB request explicitly.
  69          * Default behaviour is to map the request.
  70          */
  71         if (dma->is_compatible)
  72                 compatible = dma->is_compatible(musb_ep->dma,
  73                                 musb_ep->packet_sz, request->request.buf,
  74                                 request->request.length);
  75         if (!compatible)
  76                 return;
  77
  78         if (request->request.dma == DMA_ADDR_INVALID) {
  79                 dma_addr_t dma_addr;
  80                 int ret;
  81
  82                 dma_addr = dma_map_single(
  83                                 musb->controller,
  84                                 request->request.buf,
  85                                 request->request.length,
  86                                 request->tx
  87                                         ? DMA_TO_DEVICE
  88                                         : DMA_FROM_DEVICE);
  89                 ret = dma_mapping_error(musb->controller, dma_addr);
  90                 if (ret)
  91                         return;
  92
  93                 request->request.dma = dma_addr;
  94                 request->map_state = MUSB_MAPPED;
  95         } else {
  96                 dma_sync_single_for_device(musb->controller,
  97                         request->request.dma,
  98                         request->request.length,
  99                         request->tx
 100                                 ? DMA_TO_DEVICE
 101                                 : DMA_FROM_DEVICE);
 102                 request->map_state = PRE_MAPPED;
 103         }
 104 }
 105
 106 /* Unmap the buffer from dma and maps it back to cpu */
 107 static inline void unmap_dma_buffer(struct musb_request *request,
 108                                 struct musb *musb)
 109 {
 110         struct musb_ep *musb_ep = request->ep;
 111
 112         if (!is_buffer_mapped(request) || !musb_ep->dma)
 113                 return;
 114
 115         if (request->request.dma == DMA_ADDR_INVALID) {
 116                 dev_vdbg(musb->controller,
 117                                 "not unmapping a never mapped buffer\n");
 118                 return;
 119         }
 120         if (request->map_state == MUSB_MAPPED) {
 121                 dma_unmap_single(musb->controller,
 122                         request->request.dma,
 123                         request->request.length,
 124                         request->tx
 125                                 ? DMA_TO_DEVICE
 126                                 : DMA_FROM_DEVICE);
 127                 request->request.dma = DMA_ADDR_INVALID;
 128         } else { /* PRE_MAPPED */
 129                 dma_sync_single_for_cpu(musb->controller,
 130                         request->request.dma,
 131                         request->request.length,
 132                         request->tx
 133                                 ? DMA_TO_DEVICE
 134                                 : DMA_FROM_DEVICE);
 135         }
 136         request->map_state = UN_MAPPED;
 137 }
 138
 139 /*
 140  * Immediately complete a request.
 141  *
 142  * @param request the request to complete
 143  * @param status the status to complete the request with
 144  * Context: controller locked, IRQs blocked.
 145  */
 146 void musb_g_giveback(
 147         struct musb_ep          *ep,
 148         struct usb_request      *request,
 149         int                     status)
 150 __releases(ep->musb->lock)
 151 __acquires(ep->musb->lock)
 152 {
 153         struct musb_request     *req;
 154         struct musb             *musb;
 155         int                     busy = ep->busy;
 156
 157         req = to_musb_request(request);
 158
 159         list_del(&req->list);
 160         if (req->request.status == -EINPROGRESS)
 161                 req->request.status = status;
 162         musb = req->musb;
 163
 164         ep->busy = 1;
 165         spin_unlock(&musb->lock);
 166
 167         if (!dma_mapping_error(&musb->g.dev, request->dma))
 168                 unmap_dma_buffer(req, musb);
 169
 170         if (request->status == 0)
 171                 dev_dbg(musb->controller, "%s done request %p,  %d/%d\n",
 172                                 ep->end_point.name, request,
 173                                 req->request.actual, req->request.length);
 174         else
 175                 dev_dbg(musb->controller, "%s request %p, %d/%d fault %d\n",
 176                                 ep->end_point.name, request,
 177                                 req->request.actual, req->request.length,
 178                                 request->status);
 179         usb_gadget_giveback_request(&req->ep->end_point, &req->request);
 180         spin_lock(&musb->lock);
 181         ep->busy = busy;
 182 }
 183
 184 /* ----------------------------------------------------------------------- */
 185
 186 /*
 187  * Abort requests queued to an endpoint using the status. Synchronous.
 188  * caller locked controller and blocked irqs, and selected this ep.
 189  */
 190 static void nuke(struct musb_ep *ep, const int status)
 191 {
 192         struct musb             *musb = ep->musb;
 193         struct musb_request     *req = NULL;
 194         void __iomem *epio = ep->musb->endpoints[ep->current_epnum].regs;
 195
 196         ep->busy = 1;
 197
 198         if (is_dma_capable() && ep->dma) {
 199                 struct dma_controller   *c = ep->musb->dma_controller;
 200                 int value;
 201
 202                 if (ep->is_in) {
 203                         /*
 204                          * The programming guide says that we must not clear
 205                          * the DMAMODE bit before DMAENAB, so we only
 206                          * clear it in the second write...
 207                          */
 208                         musb_writew(epio, MUSB_TXCSR,
 209                                     MUSB_TXCSR_DMAMODE | MUSB_TXCSR_FLUSHFIFO);
 210                         musb_writew(epio, MUSB_TXCSR,
 211                                         0 | MUSB_TXCSR_FLUSHFIFO);
 212                 } else {
 213                         musb_writew(epio, MUSB_RXCSR,
 214                                         0 | MUSB_RXCSR_FLUSHFIFO);
 215                         musb_writew(epio, MUSB_RXCSR,
 216                                         0 | MUSB_RXCSR_FLUSHFIFO);
 217                 }
 218
 219                 value = c->channel_abort(ep->dma);
 220                 dev_dbg(musb->controller, "%s: abort DMA --> %d\n",
 221                                 ep->name, value);
 222                 c->channel_release(ep->dma);
 223                 ep->dma = NULL;
 224         }
 225
 226         while (!list_empty(&ep->req_list)) {
 227                 req = list_first_entry(&ep->req_list, struct musb_request, list);
 228                 musb_g_giveback(ep, &req->request, status);
 229         }
 230 }
 231
 232 /* ----------------------------------------------------------------------- */
 233
 234 /* Data transfers - pure PIO, pure DMA, or mixed mode */
 235
 236 /*
 237  * This assumes the separate CPPI engine is responding to DMA requests
 238  * from the usb core ... sequenced a bit differently from mentor dma.
 239  */
 240
 241 static inline int max_ep_writesize(struct musb *musb, struct musb_ep *ep)
 242 {
 243         if (can_bulk_split(musb, ep->type))
 244                 return ep->hw_ep->max_packet_sz_tx;
 245         else
 246                 return ep->packet_sz;
 247 }
 248
 249 /*
 250  * An endpoint is transmitting data. This can be called either from
 251  * the IRQ routine or from ep.queue() to kickstart a request on an
 252  * endpoint.
 253  *
 254  * Context: controller locked, IRQs blocked, endpoint selected
 255  */
 256 static void txstate(struct musb *musb, struct musb_request *req)
 257 {
 258         u8                      epnum = req->epnum;
 259         struct musb_ep          *musb_ep;
 260         void __iomem            *epio = musb->endpoints[epnum].regs;
 261         struct usb_request      *request;
 262         u16                     fifo_count = 0, csr;
 263         int                     use_dma = 0;
 264
 265         musb_ep = req->ep;
 266
 267         /* Check if EP is disabled */
 268         if (!musb_ep->desc) {
 269                 dev_dbg(musb->controller, "ep:%s disabled - ignore request\n",
 270                                                 musb_ep->end_point.name);
 271                 return;
 272         }
 273
 274         /* we shouldn't get here while DMA is active ... but we do ... */
 275         if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
 276                 dev_dbg(musb->controller, "dma pending...\n");
 277                 return;
 278         }
 279
 280         /* read TXCSR before */
 281         csr = musb_readw(epio, MUSB_TXCSR);
 282
 283         request = &req->request;
 284         fifo_count = min(max_ep_writesize(musb, musb_ep),
 285                         (int)(request->length - request->actual));
 286
 287         if (csr & MUSB_TXCSR_TXPKTRDY) {
 288                 dev_dbg(musb->controller, "%s old packet still ready , txcsr %03x\n",
 289                                 musb_ep->end_point.name, csr);
 290                 return;
 291         }
 292
 293         if (csr & MUSB_TXCSR_P_SENDSTALL) {
 294                 dev_dbg(musb->controller, "%s stalling, txcsr %03x\n",
 295                                 musb_ep->end_point.name, csr);
 296                 return;
 297         }
 298
 299         dev_dbg(musb->controller, "hw_ep%d, maxpacket %d, fifo count %d, txcsr %03x\n",
 300                         epnum, musb_ep->packet_sz, fifo_count,
 301                         csr);
 302
 303 #ifndef CONFIG_MUSB_PIO_ONLY
 304         if (is_buffer_mapped(req)) {
 305                 struct dma_controller   *c = musb->dma_controller;
 306                 size_t request_size;
 307
 308                 /* setup DMA, then program endpoint CSR */
 309                 request_size = min_t(size_t, request->length - request->actual,
 310                                         musb_ep->dma->max_len);
 311
 312                 use_dma = (request->dma != DMA_ADDR_INVALID && request_size);
 313
 314                 /* MUSB_TXCSR_P_ISO is still set correctly */
 315
 316                 if (musb_dma_inventra(musb) || musb_dma_ux500(musb)) {
 317                         if (request_size < musb_ep->packet_sz)
 318                                 musb_ep->dma->desired_mode = 0;
 319                         else
 320                                 musb_ep->dma->desired_mode = 1;
 321
 322                         use_dma = use_dma && c->channel_program(
 323                                         musb_ep->dma, musb_ep->packet_sz,
 324                                         musb_ep->dma->desired_mode,
 325                                         request->dma + request->actual, request_size);
 326                         if (use_dma) {
 327                                 if (musb_ep->dma->desired_mode == 0) {
 328                                         /*
 329                                          * We must not clear the DMAMODE bit
 330                                          * before the DMAENAB bit -- and the
 331                                          * latter doesn't always get cleared
 332                                          * before we get here...
 333                                          */
 334                                         csr &= ~(MUSB_TXCSR_AUTOSET
 335                                                 | MUSB_TXCSR_DMAENAB);
 336                                         musb_writew(epio, MUSB_TXCSR, csr
 337                                                 | MUSB_TXCSR_P_WZC_BITS);
 338                                         csr &= ~MUSB_TXCSR_DMAMODE;
 339                                         csr |= (MUSB_TXCSR_DMAENAB |
 340                                                         MUSB_TXCSR_MODE);
 341                                         /* against programming guide */
 342                                 } else {
 343                                         csr |= (MUSB_TXCSR_DMAENAB
 344                                                         | MUSB_TXCSR_DMAMODE
 345                                                         | MUSB_TXCSR_MODE);
 346                                         /*
 347                                          * Enable Autoset according to table
 348                                          * below
 349                                          * bulk_split hb_mult   Autoset_Enable
 350                                          *      0       0       Yes(Normal)
 351                                          *      0       >0      No(High BW ISO)
 352                                          *      1       0       Yes(HS bulk)
 353                                          *      1       >0      Yes(FS bulk)
 354                                          */
 355                                         if (!musb_ep->hb_mult ||
 356                                                 (musb_ep->hb_mult &&
 357                                                  can_bulk_split(musb,
 358                                                     musb_ep->type)))
 359                                                 csr |= MUSB_TXCSR_AUTOSET;
 360                                 }
 361                                 csr &= ~MUSB_TXCSR_P_UNDERRUN;
 362
 363                                 musb_writew(epio, MUSB_TXCSR, csr);
 364                         }
 365                 }
 366
 367                 if (is_cppi_enabled(musb)) {
 368                         /* program endpoint CSR first, then setup DMA */
 369                         csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY);
 370                         csr |= MUSB_TXCSR_DMAENAB | MUSB_TXCSR_DMAMODE |
 371                                 MUSB_TXCSR_MODE;
 372                         musb_writew(epio, MUSB_TXCSR, (MUSB_TXCSR_P_WZC_BITS &
 373                                                 ~MUSB_TXCSR_P_UNDERRUN) | csr);
 374
 375                         /* ensure writebuffer is empty */
 376                         csr = musb_readw(epio, MUSB_TXCSR);
 377
 378                         /*
 379                          * NOTE host side sets DMAENAB later than this; both are
 380                          * OK since the transfer dma glue (between CPPI and
 381                          * Mentor fifos) just tells CPPI it could start. Data
 382                          * only moves to the USB TX fifo when both fifos are
 383                          * ready.
 384                          */
 385                         /*
 386                          * "mode" is irrelevant here; handle terminating ZLPs
 387                          * like PIO does, since the hardware RNDIS mode seems
 388                          * unreliable except for the
 389                          * last-packet-is-already-short case.
 390                          */
 391                         use_dma = use_dma && c->channel_program(
 392                                         musb_ep->dma, musb_ep->packet_sz,
 393                                         0,
 394                                         request->dma + request->actual,
 395                                         request_size);
 396                         if (!use_dma) {
 397                                 c->channel_release(musb_ep->dma);
 398                                 musb_ep->dma = NULL;
 399                                 csr &= ~MUSB_TXCSR_DMAENAB;
 400                                 musb_writew(epio, MUSB_TXCSR, csr);
 401                                 /* invariant: prequest->buf is non-null */
 402                         }
 403                 } else if (tusb_dma_omap(musb))
 404                         use_dma = use_dma && c->channel_program(
 405                                         musb_ep->dma, musb_ep->packet_sz,
 406                                         request->zero,
 407                                         request->dma + request->actual,
 408                                         request_size);
 409         }
 410 #endif
 411
 412         if (!use_dma) {
 413                 /*
 414                  * Unmap the dma buffer back to cpu if dma channel
 415                  * programming fails
 416                  */
 417                 unmap_dma_buffer(req, musb);
 418
 419                 musb_write_fifo(musb_ep->hw_ep, fifo_count,
 420                                 (u8 *) (request->buf + request->actual));
 421                 request->actual += fifo_count;
 422                 csr |= MUSB_TXCSR_TXPKTRDY;
 423                 csr &= ~MUSB_TXCSR_P_UNDERRUN;
 424                 musb_writew(epio, MUSB_TXCSR, csr);
 425         }
 426
 427         /* host may already have the data when this message shows... */
 428         dev_dbg(musb->controller, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d\n",
 429                         musb_ep->end_point.name, use_dma ? "dma" : "pio",
 430                         request->actual, request->length,
 431                         musb_readw(epio, MUSB_TXCSR),
 432                         fifo_count,
 433                         musb_readw(epio, MUSB_TXMAXP));
 434 }
 435
 436 /*
 437  * FIFO state update (e.g. data ready).
 438  * Called from IRQ,  with controller locked.
 439  */
 440 void musb_g_tx(struct musb *musb, u8 epnum)
 441 {
 442         u16                     csr;
 443         struct musb_request     *req;
 444         struct usb_request      *request;
 445         u8 __iomem              *mbase = musb->mregs;
 446         struct musb_ep          *musb_ep = &musb->endpoints[epnum].ep_in;
 447         void __iomem            *epio = musb->endpoints[epnum].regs;
 448         struct dma_channel      *dma;
 449
 450         musb_ep_select(mbase, epnum);
 451         req = next_request(musb_ep);
 452         request = &req->request;
 453
 454         csr = musb_readw(epio, MUSB_TXCSR);
 455         dev_dbg(musb->controller, "<== %s, txcsr %04x\n", musb_ep->end_point.name, csr);
 456
 457         dma = is_dma_capable() ? musb_ep->dma : NULL;
 458
 459         /*
 460          * REVISIT: for high bandwidth, MUSB_TXCSR_P_INCOMPTX
 461          * probably rates reporting as a host error.
 462          */
 463         if (csr & MUSB_TXCSR_P_SENTSTALL) {
 464                 csr |=  MUSB_TXCSR_P_WZC_BITS;
 465                 csr &= ~MUSB_TXCSR_P_SENTSTALL;
 466                 musb_writew(epio, MUSB_TXCSR, csr);
 467                 return;
 468         }
 469
 470         if (csr & MUSB_TXCSR_P_UNDERRUN) {
 471                 /* We NAKed, no big deal... little reason to care. */
 472                 csr |=   MUSB_TXCSR_P_WZC_BITS;
 473                 csr &= ~(MUSB_TXCSR_P_UNDERRUN | MUSB_TXCSR_TXPKTRDY);
 474                 musb_writew(epio, MUSB_TXCSR, csr);
 475                 dev_vdbg(musb->controller, "underrun on ep%d, req %p\n",
 476                                 epnum, request);
 477         }
 478
 479         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
 480                 /*
 481                  * SHOULD NOT HAPPEN... has with CPPI though, after
 482                  * changing SENDSTALL (and other cases); harmless?
 483                  */
 484                 dev_dbg(musb->controller, "%s dma still busy?\n", musb_ep->end_point.name);
 485                 return;
 486         }
 487
 488         if (request) {
 489                 u8      is_dma = 0;
 490                 bool    short_packet = false;
 491
 492                 if (dma && (csr & MUSB_TXCSR_DMAENAB)) {
 493                         is_dma = 1;
 494                         csr |= MUSB_TXCSR_P_WZC_BITS;
 495                         csr &= ~(MUSB_TXCSR_DMAENAB | MUSB_TXCSR_P_UNDERRUN |
 496                                  MUSB_TXCSR_TXPKTRDY | MUSB_TXCSR_AUTOSET);
 497                         musb_writew(epio, MUSB_TXCSR, csr);
 498                         /* Ensure writebuffer is empty. */
 499                         csr = musb_readw(epio, MUSB_TXCSR);
 500                         request->actual += musb_ep->dma->actual_len;
 501                         dev_dbg(musb->controller, "TXCSR%d %04x, DMA off, len %zu, req %p\n",
 502                                 epnum, csr, musb_ep->dma->actual_len, request);
 503                 }
 504
 505                 /*
 506                  * First, maybe a terminating short packet. Some DMA
 507                  * engines might handle this by themselves.
 508                  */
 509                 if ((request->zero && request->length)
 510                         && (request->length % musb_ep->packet_sz == 0)
 511                         && (request->actual == request->length))
 512                                 short_packet = true;
 513
 514                 if ((musb_dma_inventra(musb) || musb_dma_ux500(musb)) &&
 515                         (is_dma && (!dma->desired_mode ||
 516                                 (request->actual &
 517                                         (musb_ep->packet_sz - 1)))))
 518                                 short_packet = true;
 519
 520                 if (short_packet) {
 521                         /*
 522                          * On DMA completion, FIFO may not be
 523                          * available yet...
 524                          */
 525                         if (csr & MUSB_TXCSR_TXPKTRDY)
 526                                 return;
 527
 528                         dev_dbg(musb->controller, "sending zero pkt\n");
 529                         musb_writew(epio, MUSB_TXCSR, MUSB_TXCSR_MODE
 530                                         | MUSB_TXCSR_TXPKTRDY);
 531                         request->zero = 0;
 532                 }
 533
 534                 if (request->actual == request->length) {
 535                         musb_g_giveback(musb_ep, request, 0);
 536                         /*
 537                          * In the giveback function the MUSB lock is
 538                          * released and acquired after sometime. During
 539                          * this time period the INDEX register could get
 540                          * changed by the gadget_queue function especially
 541                          * on SMP systems. Reselect the INDEX to be sure
 542                          * we are reading/modifying the right registers
 543                          */
 544                         musb_ep_select(mbase, epnum);
 545                         req = musb_ep->desc ? next_request(musb_ep) : NULL;
 546                         if (!req) {
 547                                 dev_dbg(musb->controller, "%s idle now\n",
 548                                         musb_ep->end_point.name);
 549                                 return;
 550                         }
 551                 }
 552
 553                 txstate(musb, req);
 554         }
 555 }
 556
 557 /* ------------------------------------------------------------ */
 558
 559 /*
 560  * Context: controller locked, IRQs blocked, endpoint selected
 561  */
 562 static void rxstate(struct musb *musb, struct musb_request *req)
 563 {
 564         const u8                epnum = req->epnum;
 565         struct usb_request      *request = &req->request;
 566         struct musb_ep          *musb_ep;
 567         void __iomem            *epio = musb->endpoints[epnum].regs;
 568         unsigned                len = 0;
 569         u16                     fifo_count;
 570         u16                     csr = musb_readw(epio, MUSB_RXCSR);
 571         struct musb_hw_ep       *hw_ep = &musb->endpoints[epnum];
 572         u8                      use_mode_1;
 573
 574         if (hw_ep->is_shared_fifo)
 575                 musb_ep = &hw_ep->ep_in;
 576         else
 577                 musb_ep = &hw_ep->ep_out;
 578
 579         fifo_count = musb_ep->packet_sz;
 580
 581         /* Check if EP is disabled */
 582         if (!musb_ep->desc) {
 583                 dev_dbg(musb->controller, "ep:%s disabled - ignore request\n",
 584                                                 musb_ep->end_point.name);
 585                 return;
 586         }
 587
 588         /* We shouldn't get here while DMA is active, but we do... */
 589         if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
 590                 dev_dbg(musb->controller, "DMA pending...\n");
 591                 return;
 592         }
 593
 594         if (csr & MUSB_RXCSR_P_SENDSTALL) {
 595                 dev_dbg(musb->controller, "%s stalling, RXCSR %04x\n",
 596                     musb_ep->end_point.name, csr);
 597                 return;
 598         }
 599
 600         if (is_cppi_enabled(musb) && is_buffer_mapped(req)) {
 601                 struct dma_controller   *c = musb->dma_controller;
 602                 struct dma_channel      *channel = musb_ep->dma;
 603
 604                 /* NOTE:  CPPI won't actually stop advancing the DMA
 605                  * queue after short packet transfers, so this is almost
 606                  * always going to run as IRQ-per-packet DMA so that
 607                  * faults will be handled correctly.
 608                  */
 609                 if (c->channel_program(channel,
 610                                 musb_ep->packet_sz,
 611                                 !request->short_not_ok,
 612                                 request->dma + request->actual,
 613                                 request->length - request->actual)) {
 614
 615                         /* make sure that if an rxpkt arrived after the irq,
 616                          * the cppi engine will be ready to take it as soon
 617                          * as DMA is enabled
 618                          */
 619                         csr &= ~(MUSB_RXCSR_AUTOCLEAR
 620                                         | MUSB_RXCSR_DMAMODE);
 621                         csr |= MUSB_RXCSR_DMAENAB | MUSB_RXCSR_P_WZC_BITS;
 622                         musb_writew(epio, MUSB_RXCSR, csr);
 623                         return;
 624                 }
 625         }
 626
 627         if (csr & MUSB_RXCSR_RXPKTRDY) {
 628                 fifo_count = musb_readw(epio, MUSB_RXCOUNT);
 629
 630                 /*
 631                  * Enable Mode 1 on RX transfers only when short_not_ok flag
 632                  * is set. Currently short_not_ok flag is set only from
 633                  * file_storage and f_mass_storage drivers
 634                  */
 635
 636                 if (request->short_not_ok && fifo_count == musb_ep->packet_sz)
 637                         use_mode_1 = 1;
 638                 else
 639                         use_mode_1 = 0;
 640
 641                 if (request->actual < request->length) {
 642                         if (!is_buffer_mapped(req))
 643                                 goto buffer_aint_mapped;
 644
 645                         if (musb_dma_inventra(musb)) {
 646                                 struct dma_controller   *c;
 647                                 struct dma_channel      *channel;
 648                                 int                     use_dma = 0;
 649                                 unsigned int transfer_size;
 650
 651                                 c = musb->dma_controller;
 652                                 channel = musb_ep->dma;
 653
 654         /* We use DMA Req mode 0 in rx_csr, and DMA controller operates in
 655          * mode 0 only. So we do not get endpoint interrupts due to DMA
 656          * completion. We only get interrupts from DMA controller.
 657          *
 658          * We could operate in DMA mode 1 if we knew the size of the tranfer
 659          * in advance. For mass storage class, request->length = what the host
 660          * sends, so that'd work.  But for pretty much everything else,
 661          * request->length is routinely more than what the host sends. For
 662          * most these gadgets, end of is signified either by a short packet,
 663          * or filling the last byte of the buffer.  (Sending extra data in
 664          * that last pckate should trigger an overflow fault.)  But in mode 1,
 665          * we don't get DMA completion interrupt for short packets.
 666          *
 667          * Theoretically, we could enable DMAReq irq (MUSB_RXCSR_DMAMODE = 1),
 668          * to get endpoint interrupt on every DMA req, but that didn't seem
 669          * to work reliably.
 670          *
 671          * REVISIT an updated g_file_storage can set req->short_not_ok, which
 672          * then becomes usable as a runtime "use mode 1" hint...
 673          */
 674
 675                                 /* Experimental: Mode1 works with mass storage use cases */
 676                                 if (use_mode_1) {
 677                                         csr |= MUSB_RXCSR_AUTOCLEAR;
 678                                         musb_writew(epio, MUSB_RXCSR, csr);
 679                                         csr |= MUSB_RXCSR_DMAENAB;
 680                                         musb_writew(epio, MUSB_RXCSR, csr);
 681
 682                                         /*
 683                                          * this special sequence (enabling and then
 684                                          * disabling MUSB_RXCSR_DMAMODE) is required
 685                                          * to get DMAReq to activate
 686                                          */
 687                                         musb_writew(epio, MUSB_RXCSR,
 688                                                 csr | MUSB_RXCSR_DMAMODE);
 689                                         musb_writew(epio, MUSB_RXCSR, csr);
 690
 691                                         transfer_size = min_t(unsigned int,
 692                                                         request->length -
 693                                                         request->actual,
 694                                                         channel->max_len);
 695                                         musb_ep->dma->desired_mode = 1;
 696                                 } else {
 697                                         if (!musb_ep->hb_mult &&
 698                                                 musb_ep->hw_ep->rx_double_buffered)
 699                                                 csr |= MUSB_RXCSR_AUTOCLEAR;
 700                                         csr |= MUSB_RXCSR_DMAENAB;
 701                                         musb_writew(epio, MUSB_RXCSR, csr);
 702
 703                                         transfer_size = min(request->length - request->actual,
 704                                                         (unsigned)fifo_count);
 705                                         musb_ep->dma->desired_mode = 0;
 706                                 }
 707
 708                                 use_dma = c->channel_program(
 709                                                 channel,
 710                                                 musb_ep->packet_sz,
 711                                                 channel->desired_mode,
 712                                                 request->dma
 713                                                 + request->actual,
 714                                                 transfer_size);
 715
 716                                 if (use_dma)
 717                                         return;
 718                         }
 719
 720                         if ((musb_dma_ux500(musb)) &&
 721                                 (request->actual < request->length)) {
 722
 723                                 struct dma_controller *c;
 724                                 struct dma_channel *channel;
 725                                 unsigned int transfer_size = 0;
 726
 727                                 c = musb->dma_controller;
 728                                 channel = musb_ep->dma;
 729
 730                                 /* In case first packet is short */
 731                                 if (fifo_count < musb_ep->packet_sz)
 732                                         transfer_size = fifo_count;
 733                                 else if (request->short_not_ok)
 734                                         transfer_size = min_t(unsigned int,
 735                                                         request->length -
 736                                                         request->actual,
 737                                                         channel->max_len);
 738                                 else
 739                                         transfer_size = min_t(unsigned int,
 740                                                         request->length -
 741                                                         request->actual,
 742                                                         (unsigned)fifo_count);
 743
 744                                 csr &= ~MUSB_RXCSR_DMAMODE;
 745                                 csr |= (MUSB_RXCSR_DMAENAB |
 746                                         MUSB_RXCSR_AUTOCLEAR);
 747
 748                                 musb_writew(epio, MUSB_RXCSR, csr);
 749
 750                                 if (transfer_size <= musb_ep->packet_sz) {
 751                                         musb_ep->dma->desired_mode = 0;
 752                                 } else {
 753                                         musb_ep->dma->desired_mode = 1;
 754                                         /* Mode must be set after DMAENAB */
 755                                         csr |= MUSB_RXCSR_DMAMODE;
 756                                         musb_writew(epio, MUSB_RXCSR, csr);
 757                                 }
 758
 759                                 if (c->channel_program(channel,
 760                                                         musb_ep->packet_sz,
 761                                                         channel->desired_mode,
 762                                                         request->dma
 763                                                         + request->actual,
 764                                                         transfer_size))
 765
 766                                         return;
 767                         }
 768
 769                         len = request->length - request->actual;
 770                         dev_dbg(musb->controller, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
 771                                         musb_ep->end_point.name,
 772                                         fifo_count, len,
 773                                         musb_ep->packet_sz);
 774
 775                         fifo_count = min_t(unsigned, len, fifo_count);
 776
 777                         if (tusb_dma_omap(musb)) {
 778                                 struct dma_controller *c = musb->dma_controller;
 779                                 struct dma_channel *channel = musb_ep->dma;
 780                                 u32 dma_addr = request->dma + request->actual;
 781                                 int ret;
 782
 783                                 ret = c->channel_program(channel,
 784                                                 musb_ep->packet_sz,
 785                                                 channel->desired_mode,
 786                                                 dma_addr,
 787                                                 fifo_count);
 788                                 if (ret)
 789                                         return;
 790                         }
 791
 792                         /*
 793                          * Unmap the dma buffer back to cpu if dma channel
 794                          * programming fails. This buffer is mapped if the
 795                          * channel allocation is successful
 796                          */
 797                         unmap_dma_buffer(req, musb);
 798
 799                         /*
 800                          * Clear DMAENAB and AUTOCLEAR for the
 801                          * PIO mode transfer
 802                          */
 803                         csr &= ~(MUSB_RXCSR_DMAENAB | MUSB_RXCSR_AUTOCLEAR);
 804                         musb_writew(epio, MUSB_RXCSR, csr);
 805
 806 buffer_aint_mapped:
 807                         musb_read_fifo(musb_ep->hw_ep, fifo_count, (u8 *)
 808                                         (request->buf + request->actual));
 809                         request->actual += fifo_count;
 810
 811                         /* REVISIT if we left anything in the fifo, flush
 812                          * it and report -EOVERFLOW
 813                          */
 814
 815                         /* ack the read! */
 816                         csr |= MUSB_RXCSR_P_WZC_BITS;
 817                         csr &= ~MUSB_RXCSR_RXPKTRDY;
 818                         musb_writew(epio, MUSB_RXCSR, csr);
 819                 }
 820         }
 821
 822         /* reach the end or short packet detected */
 823         if (request->actual == request->length ||
 824             fifo_count < musb_ep->packet_sz)
 825                 musb_g_giveback(musb_ep, request, 0);
 826 }
 827
 828 /*
 829  * Data ready for a request; called from IRQ
 830  */
 831 void musb_g_rx(struct musb *musb, u8 epnum)
 832 {
 833         u16                     csr;
 834         struct musb_request     *req;
 835         struct usb_request      *request;
 836         void __iomem            *mbase = musb->mregs;
 837         struct musb_ep          *musb_ep;
 838         void __iomem            *epio = musb->endpoints[epnum].regs;
 839         struct dma_channel      *dma;
 840         struct musb_hw_ep       *hw_ep = &musb->endpoints[epnum];
 841
 842         if (hw_ep->is_shared_fifo)
 843                 musb_ep = &hw_ep->ep_in;
 844         else
 845                 musb_ep = &hw_ep->ep_out;
 846
 847         musb_ep_select(mbase, epnum);
 848
 849         req = next_request(musb_ep);
 850         if (!req)
 851                 return;
 852
 853         request = &req->request;
 854
 855         csr = musb_readw(epio, MUSB_RXCSR);
 856         dma = is_dma_capable() ? musb_ep->dma : NULL;
 857
 858         dev_dbg(musb->controller, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
 859                         csr, dma ? " (dma)" : "", request);
 860
 861         if (csr & MUSB_RXCSR_P_SENTSTALL) {
 862                 csr |= MUSB_RXCSR_P_WZC_BITS;
 863                 csr &= ~MUSB_RXCSR_P_SENTSTALL;
 864                 musb_writew(epio, MUSB_RXCSR, csr);
 865                 return;
 866         }
 867
 868         if (csr & MUSB_RXCSR_P_OVERRUN) {
 869                 /* csr |= MUSB_RXCSR_P_WZC_BITS; */
 870                 csr &= ~MUSB_RXCSR_P_OVERRUN;
 871                 musb_writew(epio, MUSB_RXCSR, csr);
 872
 873                 dev_dbg(musb->controller, "%s iso overrun on %p\n", musb_ep->name, request);
 874                 if (request->status == -EINPROGRESS)
 875                         request->status = -EOVERFLOW;
 876         }
 877         if (csr & MUSB_RXCSR_INCOMPRX) {
 878                 /* REVISIT not necessarily an error */
 879                 dev_dbg(musb->controller, "%s, incomprx\n", musb_ep->end_point.name);
 880         }
 881
 882         if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
 883                 /* "should not happen"; likely RXPKTRDY pending for DMA */
 884                 dev_dbg(musb->controller, "%s busy, csr %04x\n",
 885                         musb_ep->end_point.name, csr);
 886                 return;
 887         }
 888
 889         if (dma && (csr & MUSB_RXCSR_DMAENAB)) {
 890                 csr &= ~(MUSB_RXCSR_AUTOCLEAR
 891                                 | MUSB_RXCSR_DMAENAB
 892                                 | MUSB_RXCSR_DMAMODE);
 893                 musb_writew(epio, MUSB_RXCSR,
 894                         MUSB_RXCSR_P_WZC_BITS | csr);
 895
 896                 request->actual += musb_ep->dma->actual_len;
 897
 898                 dev_dbg(musb->controller, "RXCSR%d %04x, dma off, %04x, len %zu, req %p\n",
 899                         epnum, csr,
 900                         musb_readw(epio, MUSB_RXCSR),
 901                         musb_ep->dma->actual_len, request);
 902
 903 #if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA) || \
 904         defined(CONFIG_USB_UX500_DMA)
 905                 /* Autoclear doesn't clear RxPktRdy for short packets */
 906                 if ((dma->desired_mode == 0 && !hw_ep->rx_double_buffered)
 907                                 || (dma->actual_len
 908                                         & (musb_ep->packet_sz - 1))) {
 909                         /* ack the read! */
 910                         csr &= ~MUSB_RXCSR_RXPKTRDY;
 911                         musb_writew(epio, MUSB_RXCSR, csr);
 912                 }
 913
 914                 /* incomplete, and not short? wait for next IN packet */
 915                 if ((request->actual < request->length)
 916                                 && (musb_ep->dma->actual_len
 917                                         == musb_ep->packet_sz)) {
 918                         /* In double buffer case, continue to unload fifo if
 919                          * there is Rx packet in FIFO.
 920                          **/
 921                         csr = musb_readw(epio, MUSB_RXCSR);
 922                         if ((csr & MUSB_RXCSR_RXPKTRDY) &&
 923                                 hw_ep->rx_double_buffered)
 924                                 goto exit;
 925                         return;
 926                 }
 927 #endif
 928                 musb_g_giveback(musb_ep, request, 0);
 929                 /*
 930                  * In the giveback function the MUSB lock is
 931                  * released and acquired after sometime. During
 932                  * this time period the INDEX register could get
 933                  * changed by the gadget_queue function especially
 934                  * on SMP systems. Reselect the INDEX to be sure
 935                  * we are reading/modifying the right registers
 936                  */
 937                 musb_ep_select(mbase, epnum);
 938
 939                 req = next_request(musb_ep);
 940                 if (!req)
 941                         return;
 942         }
 943 #if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA) || \
 944         defined(CONFIG_USB_UX500_DMA)
 945 exit:
 946 #endif
 947         /* Analyze request */
 948         rxstate(musb, req);
 949 }
 950
 951 /* ------------------------------------------------------------ */
 952
 953 static int musb_gadget_enable(struct usb_ep *ep,
 954                         const struct usb_endpoint_descriptor *desc)
 955 {
 956         unsigned long           flags;
 957         struct musb_ep          *musb_ep;
 958         struct musb_hw_ep       *hw_ep;
 959         void __iomem            *regs;
 960         struct musb             *musb;
 961         void __iomem    *mbase;
 962         u8              epnum;
 963         u16             csr;
 964         unsigned        tmp;
 965         int             status = -EINVAL;
 966
 967         if (!ep || !desc)
 968                 return -EINVAL;
 969
 970         musb_ep = to_musb_ep(ep);
 971         hw_ep = musb_ep->hw_ep;
 972         regs = hw_ep->regs;
 973         musb = musb_ep->musb;
 974         mbase = musb->mregs;
 975         epnum = musb_ep->current_epnum;
 976
 977         spin_lock_irqsave(&musb->lock, flags);
 978
 979         if (musb_ep->desc) {
 980                 status = -EBUSY;
 981                 goto fail;
 982         }
 983         musb_ep->type = usb_endpoint_type(desc);
 984
 985         /* check direction and (later) maxpacket size against endpoint */
 986         if (usb_endpoint_num(desc) != epnum)
 987                 goto fail;
 988
 989         /* REVISIT this rules out high bandwidth periodic transfers */
 990         tmp = usb_endpoint_maxp(desc);
 991         if (tmp & ~0x07ff) {
 992                 int ok;
 993
 994                 if (usb_endpoint_dir_in(desc))
 995                         ok = musb->hb_iso_tx;
 996                 else
 997                         ok = musb->hb_iso_rx;
 998
 999                 if (!ok) {
1000                         dev_dbg(musb->controller, "no support for high bandwidth ISO\n");
1001                         goto fail;
1002                 }
1003                 musb_ep->hb_mult = (tmp >> 11) & 3;
1004         } else {
1005                 musb_ep->hb_mult = 0;
1006         }
1007
1008         musb_ep->packet_sz = tmp & 0x7ff;
1009         tmp = musb_ep->packet_sz * (musb_ep->hb_mult + 1);
1010
1011         /* enable the interrupts for the endpoint, set the endpoint
1012          * packet size (or fail), set the mode, clear the fifo
1013          */
1014         musb_ep_select(mbase, epnum);
1015         if (usb_endpoint_dir_in(desc)) {
1016
1017                 if (hw_ep->is_shared_fifo)
1018                         musb_ep->is_in = 1;
1019                 if (!musb_ep->is_in)
1020                         goto fail;
1021
1022                 if (tmp > hw_ep->max_packet_sz_tx) {
1023                         dev_dbg(musb->controller, "packet size beyond hardware FIFO size\n");
1024                         goto fail;
1025                 }
1026
1027                 musb->intrtxe |= (1 << epnum);
1028                 musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe);
1029
1030                 /* REVISIT if can_bulk_split(), use by updating "tmp";
1031                  * likewise high bandwidth periodic tx
1032                  */
1033                 /* Set TXMAXP with the FIFO size of the endpoint
1034                  * to disable double buffering mode.
1035                  */
1036                 if (musb->double_buffer_not_ok) {
1037                         musb_writew(regs, MUSB_TXMAXP, hw_ep->max_packet_sz_tx);
1038                 } else {
1039                         if (can_bulk_split(musb, musb_ep->type))
1040                                 musb_ep->hb_mult = (hw_ep->max_packet_sz_tx /
1041                                                         musb_ep->packet_sz) - 1;
1042                         musb_writew(regs, MUSB_TXMAXP, musb_ep->packet_sz
1043                                         | (musb_ep->hb_mult << 11));
1044                 }
1045
1046                 csr = MUSB_TXCSR_MODE | MUSB_TXCSR_CLRDATATOG;
1047                 if (musb_readw(regs, MUSB_TXCSR)
1048                                 & MUSB_TXCSR_FIFONOTEMPTY)
1049                         csr |= MUSB_TXCSR_FLUSHFIFO;
1050                 if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
1051                         csr |= MUSB_TXCSR_P_ISO;
1052
1053                 /* set twice in case of double buffering */
1054                 musb_writew(regs, MUSB_TXCSR, csr);
1055                 /* REVISIT may be inappropriate w/o FIFONOTEMPTY ... */
1056                 musb_writew(regs, MUSB_TXCSR, csr);
1057
1058         } else {
1059
1060                 if (hw_ep->is_shared_fifo)
1061                         musb_ep->is_in = 0;
1062                 if (musb_ep->is_in)
1063                         goto fail;
1064
1065                 if (tmp > hw_ep->max_packet_sz_rx) {
1066                         dev_dbg(musb->controller, "packet size beyond hardware FIFO size\n");
1067                         goto fail;
1068                 }
1069
1070                 musb->intrrxe |= (1 << epnum);
1071                 musb_writew(mbase, MUSB_INTRRXE, musb->intrrxe);
1072
1073                 /* REVISIT if can_bulk_combine() use by updating "tmp"
1074                  * likewise high bandwidth periodic rx
1075                  */
1076                 /* Set RXMAXP with the FIFO size of the endpoint
1077                  * to disable double buffering mode.
1078                  */
1079                 if (musb->double_buffer_not_ok)
1080                         musb_writew(regs, MUSB_RXMAXP, hw_ep->max_packet_sz_tx);
1081                 else
1082                         musb_writew(regs, MUSB_RXMAXP, musb_ep->packet_sz
1083                                         | (musb_ep->hb_mult << 11));
1084
1085                 /* force shared fifo to OUT-only mode */
1086                 if (hw_ep->is_shared_fifo) {
1087                         csr = musb_readw(regs, MUSB_TXCSR);
1088                         csr &= ~(MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY);
1089                         musb_writew(regs, MUSB_TXCSR, csr);
1090                 }
1091
1092                 csr = MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_CLRDATATOG;
1093                 if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
1094                         csr |= MUSB_RXCSR_P_ISO;
1095                 else if (musb_ep->type == USB_ENDPOINT_XFER_INT)
1096                         csr |= MUSB_RXCSR_DISNYET;
1097
1098                 /* set twice in case of double buffering */
1099                 musb_writew(regs, MUSB_RXCSR, csr);
1100                 musb_writew(regs, MUSB_RXCSR, csr);
1101         }
1102
1103         /* NOTE:  all the I/O code _should_ work fine without DMA, in case
1104          * for some reason you run out of channels here.
1105          */
1106         if (is_dma_capable() && musb->dma_controller) {
1107                 struct dma_controller   *c = musb->dma_controller;
1108
1109                 musb_ep->dma = c->channel_alloc(c, hw_ep,
1110                                 (desc->bEndpointAddress & USB_DIR_IN));
1111         } else
1112                 musb_ep->dma = NULL;
1113
1114         musb_ep->desc = desc;
1115         musb_ep->busy = 0;
1116         musb_ep->wedged = 0;
1117         status = 0;
1118
1119         pr_debug("%s periph: enabled %s for %s %s, %smaxpacket %d\n",
1120                         musb_driver_name, musb_ep->end_point.name,
1121                         ({ char *s; switch (musb_ep->type) {
1122                         case USB_ENDPOINT_XFER_BULK:    s = "bulk"; break;
1123                         case USB_ENDPOINT_XFER_INT:     s = "int"; break;
1124                         default:                        s = "iso"; break;
1125                         } s; }),
1126                         musb_ep->is_in ? "IN" : "OUT",
1127                         musb_ep->dma ? "dma, " : "",
1128                         musb_ep->packet_sz);
1129
1130         schedule_work(&musb->irq_work);
1131
1132 fail:
1133         spin_unlock_irqrestore(&musb->lock, flags);
1134         return status;
1135 }
1136
1137 /*
1138  * Disable an endpoint flushing all requests queued.
1139  */
1140 static int musb_gadget_disable(struct usb_ep *ep)
1141 {
1142         unsigned long   flags;
1143         struct musb     *musb;
1144         u8              epnum;
1145         struct musb_ep  *musb_ep;
1146         void __iomem    *epio;
1147         int             status = 0;
1148
1149         musb_ep = to_musb_ep(ep);
1150         musb = musb_ep->musb;
1151         epnum = musb_ep->current_epnum;
1152         epio = musb->endpoints[epnum].regs;
1153
1154         spin_lock_irqsave(&musb->lock, flags);
1155         musb_ep_select(musb->mregs, epnum);
1156
1157         /* zero the endpoint sizes */
1158         if (musb_ep->is_in) {
1159                 musb->intrtxe &= ~(1 << epnum);
1160                 musb_writew(musb->mregs, MUSB_INTRTXE, musb->intrtxe);
1161                 musb_writew(epio, MUSB_TXMAXP, 0);
1162         } else {
1163                 musb->intrrxe &= ~(1 << epnum);
1164                 musb_writew(musb->mregs, MUSB_INTRRXE, musb->intrrxe);
1165                 musb_writew(epio, MUSB_RXMAXP, 0);
1166         }
1167
1168         musb_ep->desc = NULL;
1169         musb_ep->end_point.desc = NULL;
1170
1171         /* abort all pending DMA and requests */
1172         nuke(musb_ep, -ESHUTDOWN);
1173
1174         schedule_work(&musb->irq_work);
1175
1176         spin_unlock_irqrestore(&(musb->lock), flags);
1177
1178         dev_dbg(musb->controller, "%s\n", musb_ep->end_point.name);
1179
1180         return status;
1181 }
1182
1183 /*
1184  * Allocate a request for an endpoint.
1185  * Reused by ep0 code.
1186  */
1187 struct usb_request *musb_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
1188 {
1189         struct musb_ep          *musb_ep = to_musb_ep(ep);
1190         struct musb             *musb = musb_ep->musb;
1191         struct musb_request     *request = NULL;
1192
1193         request = kzalloc(sizeof *request, gfp_flags);
1194         if (!request) {
1195                 dev_dbg(musb->controller, "not enough memory\n");
1196                 return NULL;
1197         }
1198
1199         request->request.dma = DMA_ADDR_INVALID;
1200         request->epnum = musb_ep->current_epnum;
1201         request->ep = musb_ep;
1202
1203         return &request->request;
1204 }
1205
1206 /*
1207  * Free a request
1208  * Reused by ep0 code.
1209  */
1210 void musb_free_request(struct usb_ep *ep, struct usb_request *req)
1211 {
1212         kfree(to_musb_request(req));
1213 }
1214
1215 static LIST_HEAD(buffers);
1216
1217 struct free_record {
1218         struct list_head        list;
1219         struct device           *dev;
1220         unsigned                bytes;
1221         dma_addr_t              dma;
1222 };
1223
1224 /*
1225  * Context: controller locked, IRQs blocked.
1226  */
1227 void musb_ep_restart(struct musb *musb, struct musb_request *req)
1228 {
1229         dev_dbg(musb->controller, "<== %s request %p len %u on hw_ep%d\n",
1230                 req->tx ? "TX/IN" : "RX/OUT",
1231                 &req->request, req->request.length, req->epnum);
1232
1233         musb_ep_select(musb->mregs, req->epnum);
1234         if (req->tx)
1235                 txstate(musb, req);
1236         else
1237                 rxstate(musb, req);
1238 }
1239
1240 static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
1241                         gfp_t gfp_flags)
1242 {
1243         struct musb_ep          *musb_ep;
1244         struct musb_request     *request;
1245         struct musb             *musb;
1246         int                     status = 0;
1247         unsigned long           lockflags;
1248
1249         if (!ep || !req)
1250                 return -EINVAL;
1251         if (!req->buf)
1252                 return -ENODATA;
1253
1254         musb_ep = to_musb_ep(ep);
1255         musb = musb_ep->musb;
1256
1257         request = to_musb_request(req);
1258         request->musb = musb;
1259
1260         if (request->ep != musb_ep)
1261                 return -EINVAL;
1262
1263         dev_dbg(musb->controller, "<== to %s request=%p\n", ep->name, req);
1264
1265         /* request is mine now... */
1266         request->request.actual = 0;
1267         request->request.status = -EINPROGRESS;
1268         request->epnum = musb_ep->current_epnum;
1269         request->tx = musb_ep->is_in;
1270
1271         map_dma_buffer(request, musb, musb_ep);
1272
1273         spin_lock_irqsave(&musb->lock, lockflags);
1274
1275         /* don't queue if the ep is down */
1276         if (!musb_ep->desc) {
1277                 dev_dbg(musb->controller, "req %p queued to %s while ep %s\n",
1278                                 req, ep->name, "disabled");
1279                 status = -ESHUTDOWN;
1280                 unmap_dma_buffer(request, musb);
1281                 goto unlock;
1282         }
1283
1284         /* add request to the list */
1285         list_add_tail(&request->list, &musb_ep->req_list);
1286
1287         /* it this is the head of the queue, start i/o ... */
1288         if (!musb_ep->busy && &request->list == musb_ep->req_list.next)
1289                 musb_ep_restart(musb, request);
1290
1291 unlock:
1292         spin_unlock_irqrestore(&musb->lock, lockflags);
1293         return status;
1294 }
1295
1296 static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *request)
1297 {
1298         struct musb_ep          *musb_ep = to_musb_ep(ep);
1299         struct musb_request     *req = to_musb_request(request);
1300         struct musb_request     *r;
1301         unsigned long           flags;
1302         int                     status = 0;
1303         struct musb             *musb = musb_ep->musb;
1304
1305         if (!ep || !request || to_musb_request(request)->ep != musb_ep)
1306                 return -EINVAL;
1307
1308         spin_lock_irqsave(&musb->lock, flags);
1309
1310         list_for_each_entry(r, &musb_ep->req_list, list) {
1311                 if (r == req)
1312                         break;
1313         }
1314         if (r != req) {
1315                 dev_dbg(musb->controller, "request %p not queued to %s\n", request, ep->name);
1316                 status = -EINVAL;
1317                 goto done;
1318         }
1319
1320         /* if the hardware doesn't have the request, easy ... */
1321         if (musb_ep->req_list.next != &req->list || musb_ep->busy)
1322                 musb_g_giveback(musb_ep, request, -ECONNRESET);
1323
1324         /* ... else abort the dma transfer ... */
1325         else if (is_dma_capable() && musb_ep->dma) {
1326                 struct dma_controller   *c = musb->dma_controller;
1327
1328                 musb_ep_select(musb->mregs, musb_ep->current_epnum);
1329                 if (c->channel_abort)
1330                         status = c->channel_abort(musb_ep->dma);
1331                 else
1332                         status = -EBUSY;
1333                 if (status == 0)
1334                         musb_g_giveback(musb_ep, request, -ECONNRESET);
1335         } else {
1336                 /* NOTE: by sticking to easily tested hardware/driver states,
1337                  * we leave counting of in-flight packets imprecise.
1338                  */
1339                 musb_g_giveback(musb_ep, request, -ECONNRESET);
1340         }
1341
1342 done:
1343         spin_unlock_irqrestore(&musb->lock, flags);
1344         return status;
1345 }
1346
1347 /*
1348  * Set or clear the halt bit of an endpoint. A halted enpoint won't tx/rx any
1349  * data but will queue requests.
1350  *
1351  * exported to ep0 code
1352  */
1353 static int musb_gadget_set_halt(struct usb_ep *ep, int value)
1354 {
1355         struct musb_ep          *musb_ep = to_musb_ep(ep);
1356         u8                      epnum = musb_ep->current_epnum;
1357         struct musb             *musb = musb_ep->musb;
1358         void __iomem            *epio = musb->endpoints[epnum].regs;
1359         void __iomem            *mbase;
1360         unsigned long           flags;
1361         u16                     csr;
1362         struct musb_request     *request;
1363         int                     status = 0;
1364
1365         if (!ep)
1366                 return -EINVAL;
1367         mbase = musb->mregs;
1368
1369         spin_lock_irqsave(&musb->lock, flags);
1370
1371         if ((USB_ENDPOINT_XFER_ISOC == musb_ep->type)) {
1372                 status = -EINVAL;
1373                 goto done;
1374         }
1375
1376         musb_ep_select(mbase, epnum);
1377
1378         request = next_request(musb_ep);
1379         if (value) {
1380                 if (request) {
1381                         dev_dbg(musb->controller, "request in progress, cannot halt %s\n",
1382                             ep->name);
1383                         status = -EAGAIN;
1384                         goto done;
1385                 }
1386                 /* Cannot portably stall with non-empty FIFO */
1387                 if (musb_ep->is_in) {
1388                         csr = musb_readw(epio, MUSB_TXCSR);
1389                         if (csr & MUSB_TXCSR_FIFONOTEMPTY) {
1390                                 dev_dbg(musb->controller, "FIFO busy, cannot halt %s\n", ep->name);
1391                                 status = -EAGAIN;
1392                                 goto done;
1393                         }
1394                 }
1395         } else
1396                 musb_ep->wedged = 0;
1397
1398         /* set/clear the stall and toggle bits */
1399         dev_dbg(musb->controller, "%s: %s stall\n", ep->name, value ? "set" : "clear");
1400         if (musb_ep->is_in) {
1401                 csr = musb_readw(epio, MUSB_TXCSR);
1402                 csr |= MUSB_TXCSR_P_WZC_BITS
1403                         | MUSB_TXCSR_CLRDATATOG;
1404                 if (value)
1405                         csr |= MUSB_TXCSR_P_SENDSTALL;
1406                 else
1407                         csr &= ~(MUSB_TXCSR_P_SENDSTALL
1408                                 | MUSB_TXCSR_P_SENTSTALL);
1409                 csr &= ~MUSB_TXCSR_TXPKTRDY;
1410                 musb_writew(epio, MUSB_TXCSR, csr);
1411         } else {
1412                 csr = musb_readw(epio, MUSB_RXCSR);
1413                 csr |= MUSB_RXCSR_P_WZC_BITS
1414                         | MUSB_RXCSR_FLUSHFIFO
1415                         | MUSB_RXCSR_CLRDATATOG;
1416                 if (value)
1417                         csr |= MUSB_RXCSR_P_SENDSTALL;
1418                 else
1419                         csr &= ~(MUSB_RXCSR_P_SENDSTALL
1420                                 | MUSB_RXCSR_P_SENTSTALL);
1421                 musb_writew(epio, MUSB_RXCSR, csr);
1422         }
1423
1424         /* maybe start the first request in the queue */
1425         if (!musb_ep->busy && !value && request) {
1426                 dev_dbg(musb->controller, "restarting the request\n");
1427                 musb_ep_restart(musb, request);
1428         }
1429
1430 done:
1431         spin_unlock_irqrestore(&musb->lock, flags);
1432         return status;
1433 }
1434
1435 /*
1436  * Sets the halt feature with the clear requests ignored
1437  */
1438 static int musb_gadget_set_wedge(struct usb_ep *ep)
1439 {
1440         struct musb_ep          *musb_ep = to_musb_ep(ep);
1441
1442         if (!ep)
1443                 return -EINVAL;
1444
1445         musb_ep->wedged = 1;
1446
1447         return usb_ep_set_halt(ep);
1448 }
1449
1450 static int musb_gadget_fifo_status(struct usb_ep *ep)
1451 {
1452         struct musb_ep          *musb_ep = to_musb_ep(ep);
1453         void __iomem            *epio = musb_ep->hw_ep->regs;
1454         int                     retval = -EINVAL;
1455
1456         if (musb_ep->desc && !musb_ep->is_in) {
1457                 struct musb             *musb = musb_ep->musb;
1458                 int                     epnum = musb_ep->current_epnum;
1459                 void __iomem            *mbase = musb->mregs;
1460                 unsigned long           flags;
1461
1462                 spin_lock_irqsave(&musb->lock, flags);
1463
1464                 musb_ep_select(mbase, epnum);
1465                 /* FIXME return zero unless RXPKTRDY is set */
1466                 retval = musb_readw(epio, MUSB_RXCOUNT);
1467
1468                 spin_unlock_irqrestore(&musb->lock, flags);
1469         }
1470         return retval;
1471 }
1472
1473 static void musb_gadget_fifo_flush(struct usb_ep *ep)
1474 {
1475         struct musb_ep  *musb_ep = to_musb_ep(ep);
1476         struct musb     *musb = musb_ep->musb;
1477         u8              epnum = musb_ep->current_epnum;
1478         void __iomem    *epio = musb->endpoints[epnum].regs;
1479         void __iomem    *mbase;
1480         unsigned long   flags;
1481         u16             csr;
1482
1483         mbase = musb->mregs;
1484
1485         spin_lock_irqsave(&musb->lock, flags);
1486         musb_ep_select(mbase, (u8) epnum);
1487
1488         /* disable interrupts */
1489         musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe & ~(1 << epnum));
1490
1491         if (musb_ep->is_in) {
1492                 csr = musb_readw(epio, MUSB_TXCSR);
1493                 if (csr & MUSB_TXCSR_FIFONOTEMPTY) {
1494                         csr |= MUSB_TXCSR_FLUSHFIFO | MUSB_TXCSR_P_WZC_BITS;
1495                         /*
1496                          * Setting both TXPKTRDY and FLUSHFIFO makes controller
1497                          * to interrupt current FIFO loading, but not flushing
1498                          * the already loaded ones.
1499                          */
1500                         csr &= ~MUSB_TXCSR_TXPKTRDY;
1501                         musb_writew(epio, MUSB_TXCSR, csr);
1502                         /* REVISIT may be inappropriate w/o FIFONOTEMPTY ... */
1503                         musb_writew(epio, MUSB_TXCSR, csr);
1504                 }
1505         } else {
1506                 csr = musb_readw(epio, MUSB_RXCSR);
1507                 csr |= MUSB_RXCSR_FLUSHFIFO | MUSB_RXCSR_P_WZC_BITS;
1508                 musb_writew(epio, MUSB_RXCSR, csr);
1509                 musb_writew(epio, MUSB_RXCSR, csr);
1510         }
1511
1512         /* re-enable interrupt */
1513         musb_writew(mbase, MUSB_INTRTXE, musb->intrtxe);
1514         spin_unlock_irqrestore(&musb->lock, flags);
1515 }
1516
1517 static const struct usb_ep_ops musb_ep_ops = {
1518         .enable         = musb_gadget_enable,
1519         .disable        = musb_gadget_disable,
1520         .alloc_request  = musb_alloc_request,
1521         .free_request   = musb_free_request,
1522         .queue          = musb_gadget_queue,
1523         .dequeue        = musb_gadget_dequeue,
1524         .set_halt       = musb_gadget_set_halt,
1525         .set_wedge      = musb_gadget_set_wedge,
1526         .fifo_status    = musb_gadget_fifo_status,
1527         .fifo_flush     = musb_gadget_fifo_flush
1528 };
1529
1530 /* ----------------------------------------------------------------------- */
1531
1532 static int musb_gadget_get_frame(struct usb_gadget *gadget)
1533 {
1534         struct musb     *musb = gadget_to_musb(gadget);
1535
1536         return (int)musb_readw(musb->mregs, MUSB_FRAME);
1537 }
1538
1539 static int musb_gadget_wakeup(struct usb_gadget *gadget)
1540 {
1541         struct musb     *musb = gadget_to_musb(gadget);
1542         void __iomem    *mregs = musb->mregs;
1543         unsigned long   flags;
1544         int             status = -EINVAL;
1545         u8              power, devctl;
1546         int             retries;
1547
1548         spin_lock_irqsave(&musb->lock, flags);
1549
1550         switch (musb->xceiv->otg->state) {
1551         case OTG_STATE_B_PERIPHERAL:
1552                 /* NOTE:  OTG state machine doesn't include B_SUSPENDED;
1553                  * that's part of the standard usb 1.1 state machine, and
1554                  * doesn't affect OTG transitions.
1555                  */
1556                 if (musb->may_wakeup && musb->is_suspended)
1557                         break;
1558                 goto done;
1559         case OTG_STATE_B_IDLE:
1560                 /* Start SRP ... OTG not required. */
1561                 devctl = musb_readb(mregs, MUSB_DEVCTL);
1562                 dev_dbg(musb->controller, "Sending SRP: devctl: %02x\n", devctl);
1563                 devctl |= MUSB_DEVCTL_SESSION;
1564                 musb_writeb(mregs, MUSB_DEVCTL, devctl);
1565                 devctl = musb_readb(mregs, MUSB_DEVCTL);
1566                 retries = 100;
1567                 while (!(devctl & MUSB_DEVCTL_SESSION)) {
1568                         devctl = musb_readb(mregs, MUSB_DEVCTL);
1569                         if (retries-- < 1)
1570                                 break;
1571                 }
1572                 retries = 10000;
1573                 while (devctl & MUSB_DEVCTL_SESSION) {
1574                         devctl = musb_readb(mregs, MUSB_DEVCTL);
1575                         if (retries-- < 1)
1576                                 break;
1577                 }
1578
1579                 spin_unlock_irqrestore(&musb->lock, flags);
1580                 otg_start_srp(musb->xceiv->otg);
1581                 spin_lock_irqsave(&musb->lock, flags);
1582
1583                 /* Block idling for at least 1s */
1584                 musb_platform_try_idle(musb,
1585                         jiffies + msecs_to_jiffies(1 * HZ));
1586
1587                 status = 0;
1588                 goto done;
1589         default:
1590                 dev_dbg(musb->controller, "Unhandled wake: %s\n",
1591                         usb_otg_state_string(musb->xceiv->otg->state));
1592                 goto done;
1593         }
1594
1595         status = 0;
1596
1597         power = musb_readb(mregs, MUSB_POWER);
1598         power |= MUSB_POWER_RESUME;
1599         musb_writeb(mregs, MUSB_POWER, power);
1600         dev_dbg(musb->controller, "issue wakeup\n");
1601
1602         /* FIXME do this next chunk in a timer callback, no udelay */
1603         mdelay(2);
1604
1605         power = musb_readb(mregs, MUSB_POWER);
1606         power &= ~MUSB_POWER_RESUME;
1607         musb_writeb(mregs, MUSB_POWER, power);
1608 done:
1609         spin_unlock_irqrestore(&musb->lock, flags);
1610         return status;
1611 }
1612
1613 static int
1614 musb_gadget_set_self_powered(struct usb_gadget *gadget, int is_selfpowered)
1615 {
1616         gadget->is_selfpowered = !!is_selfpowered;
1617         return 0;
1618 }
1619
1620 static void musb_pullup(struct musb *musb, int is_on)
1621 {
1622         u8 power;
1623
1624         power = musb_readb(musb->mregs, MUSB_POWER);
1625         if (is_on)
1626                 power |= MUSB_POWER_SOFTCONN;
1627         else
1628                 power &= ~MUSB_POWER_SOFTCONN;
1629
1630         /* FIXME if on, HdrcStart; if off, HdrcStop */
1631
1632         dev_dbg(musb->controller, "gadget D+ pullup %s\n",
1633                 is_on ? "on" : "off");
1634         musb_writeb(musb->mregs, MUSB_POWER, power);
1635 }
1636
1637 #if 0
1638 static int musb_gadget_vbus_session(struct usb_gadget *gadget, int is_active)
1639 {
1640         dev_dbg(musb->controller, "<= %s =>\n", __func__);
1641
1642         /*
1643          * FIXME iff driver's softconnect flag is set (as it is during probe,
1644          * though that can clear it), just musb_pullup().
1645          */
1646
1647         return -EINVAL;
1648 }
1649 #endif
1650
1651 static int musb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
1652 {
1653         struct musb     *musb = gadget_to_musb(gadget);
1654
1655         if (!musb->xceiv->set_power)
1656                 return -EOPNOTSUPP;
1657         return usb_phy_set_power(musb->xceiv, mA);
1658 }
1659
1660 static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
1661 {
1662         struct musb     *musb = gadget_to_musb(gadget);
1663         unsigned long   flags;
1664
1665         is_on = !!is_on;
1666
1667         pm_runtime_get_sync(musb->controller);
1668
1669         /* NOTE: this assumes we are sensing vbus; we'd rather
1670          * not pullup unless the B-session is active.
1671          */
1672         spin_lock_irqsave(&musb->lock, flags);
1673         if (is_on != musb->softconnect) {
1674                 musb->softconnect = is_on;
1675                 musb_pullup(musb, is_on);
1676         }
1677         spin_unlock_irqrestore(&musb->lock, flags);
1678
1679         pm_runtime_put(musb->controller);
1680
1681         return 0;
1682 }
1683
1684 #ifdef CONFIG_BLACKFIN
1685 static struct usb_ep *musb_match_ep(struct usb_gadget *g,
1686                 struct usb_endpoint_descriptor *desc,
1687                 struct usb_ss_ep_comp_descriptor *ep_comp)
1688 {
1689         struct usb_ep *ep = NULL;
1690
1691         switch (usb_endpoint_type(desc)) {
1692         case USB_ENDPOINT_XFER_ISOC:
1693         case USB_ENDPOINT_XFER_BULK:
1694                 if (usb_endpoint_dir_in(desc))
1695                         ep = gadget_find_ep_by_name(g, "ep5in");
1696                 else
1697                         ep = gadget_find_ep_by_name(g, "ep6out");
1698                 break;
1699         case USB_ENDPOINT_XFER_INT:
1700                 if (usb_endpoint_dir_in(desc))
1701                         ep = gadget_find_ep_by_name(g, "ep1in");
1702                 else
1703                         ep = gadget_find_ep_by_name(g, "ep2out");
1704                 break;
1705         default:
1706                 break;
1707         }
1708
1709         if (ep && usb_gadget_ep_match_desc(g, ep, desc, ep_comp))
1710                 return ep;
1711
1712         return NULL;
1713 }
1714 #else
1715 #define musb_match_ep NULL
1716 #endif
1717
1718 static int musb_gadget_start(struct usb_gadget *g,
1719                 struct usb_gadget_driver *driver);
1720 static int musb_gadget_stop(struct usb_gadget *g);
1721
1722 static const struct usb_gadget_ops musb_gadget_operations = {
1723         .get_frame              = musb_gadget_get_frame,
1724         .wakeup                 = musb_gadget_wakeup,
1725         .set_selfpowered        = musb_gadget_set_self_powered,
1726         /* .vbus_session                = musb_gadget_vbus_session, */
1727         .vbus_draw              = musb_gadget_vbus_draw,
1728         .pullup                 = musb_gadget_pullup,
1729         .udc_start              = musb_gadget_start,
1730         .udc_stop               = musb_gadget_stop,
1731         .match_ep               = musb_match_ep,
1732 };
1733
1734 /* ----------------------------------------------------------------------- */
1735
1736 /* Registration */
1737
1738 /* Only this registration code "knows" the rule (from USB standards)
1739  * about there being only one external upstream port.  It assumes
1740  * all peripheral ports are external...
1741  */
1742
1743 static void
1744 init_peripheral_ep(struct musb *musb, struct musb_ep *ep, u8 epnum, int is_in)
1745 {
1746         struct musb_hw_ep       *hw_ep = musb->endpoints + epnum;
1747
1748         memset(ep, 0, sizeof *ep);
1749
1750         ep->current_epnum = epnum;
1751         ep->musb = musb;
1752         ep->hw_ep = hw_ep;
1753         ep->is_in = is_in;
1754
1755         INIT_LIST_HEAD(&ep->req_list);
1756
1757         sprintf(ep->name, "ep%d%s", epnum,
1758                         (!epnum || hw_ep->is_shared_fifo) ? "" : (
1759                                 is_in ? "in" : "out"));
1760         ep->end_point.name = ep->name;
1761         INIT_LIST_HEAD(&ep->end_point.ep_list);
1762         if (!epnum) {
1763                 usb_ep_set_maxpacket_limit(&ep->end_point, 64);
1764                 ep->end_point.caps.type_control = true;
1765                 ep->end_point.ops = &musb_g_ep0_ops;
1766                 musb->g.ep0 = &ep->end_point;
1767         } else {
1768                 if (is_in)
1769                         usb_ep_set_maxpacket_limit(&ep->end_point, hw_ep->max_packet_sz_tx);
1770                 else
1771                         usb_ep_set_maxpacket_limit(&ep->end_point, hw_ep->max_packet_sz_rx);
1772                 ep->end_point.caps.type_iso = true;
1773                 ep->end_point.caps.type_bulk = true;
1774                 ep->end_point.caps.type_int = true;
1775                 ep->end_point.ops = &musb_ep_ops;
1776                 list_add_tail(&ep->end_point.ep_list, &musb->g.ep_list);
1777         }
1778
1779         if (!epnum || hw_ep->is_shared_fifo) {
1780                 ep->end_point.caps.dir_in = true;
1781                 ep->end_point.caps.dir_out = true;
1782         } else if (is_in)
1783                 ep->end_point.caps.dir_in = true;
1784         else
1785                 ep->end_point.caps.dir_out = true;
1786 }
1787
1788 /*
1789  * Initialize the endpoints exposed to peripheral drivers, with backlinks
1790  * to the rest of the driver state.
1791  */
1792 static inline void musb_g_init_endpoints(struct musb *musb)
1793 {
1794         u8                      epnum;
1795         struct musb_hw_ep       *hw_ep;
1796         unsigned                count = 0;
1797
1798         /* initialize endpoint list just once */
1799         INIT_LIST_HEAD(&(musb->g.ep_list));
1800
1801         for (epnum = 0, hw_ep = musb->endpoints;
1802                         epnum < musb->nr_endpoints;
1803                         epnum++, hw_ep++) {
1804                 if (hw_ep->is_shared_fifo /* || !epnum */) {
1805                         init_peripheral_ep(musb, &hw_ep->ep_in, epnum, 0);
1806                         count++;
1807                 } else {
1808                         if (hw_ep->max_packet_sz_tx) {
1809                                 init_peripheral_ep(musb, &hw_ep->ep_in,
1810                                                         epnum, 1);
1811                                 count++;
1812                         }
1813                         if (hw_ep->max_packet_sz_rx) {
1814                                 init_peripheral_ep(musb, &hw_ep->ep_out,
1815                                                         epnum, 0);
1816                                 count++;
1817                         }
1818                 }
1819         }
1820 }
1821
1822 /* called once during driver setup to initialize and link into
1823  * the driver model; memory is zeroed.
1824  */
1825 int musb_gadget_setup(struct musb *musb)
1826 {
1827         int status;
1828
1829         /* REVISIT minor race:  if (erroneously) setting up two
1830          * musb peripherals at the same time, only the bus lock
1831          * is probably held.
1832          */
1833
1834         musb->g.ops = &musb_gadget_operations;
1835         musb->g.max_speed = USB_SPEED_HIGH;
1836         musb->g.speed = USB_SPEED_UNKNOWN;
1837
1838         MUSB_DEV_MODE(musb);
1839         musb->xceiv->otg->default_a = 0;
1840         musb->xceiv->otg->state = OTG_STATE_B_IDLE;
1841
1842         /* this "gadget" abstracts/virtualizes the controller */
1843         musb->g.name = musb_driver_name;
1844 #if IS_ENABLED(CONFIG_USB_MUSB_DUAL_ROLE)
1845         musb->g.is_otg = 1;
1846 #elif IS_ENABLED(CONFIG_USB_MUSB_GADGET)
1847         musb->g.is_otg = 0;
1848 #endif
1849
1850         musb_g_init_endpoints(musb);
1851
1852         musb->is_active = 0;
1853         musb_platform_try_idle(musb, 0);
1854
1855         status = usb_add_gadget_udc(musb->controller, &musb->g);
1856         if (status)
1857                 goto err;
1858
1859         return 0;
1860 err:
1861         musb->g.dev.parent = NULL;
1862         device_unregister(&musb->g.dev);
1863         return status;
1864 }
1865
1866 void musb_gadget_cleanup(struct musb *musb)
1867 {
1868         if (musb->port_mode == MUSB_PORT_MODE_HOST)
1869                 return;
1870         usb_del_gadget_udc(&musb->g);
1871 }
1872
1873 /*
1874  * Register the gadget driver. Used by gadget drivers when
1875  * registering themselves with the controller.
1876  *
1877  * -EINVAL something went wrong (not driver)
1878  * -EBUSY another gadget is already using the controller
1879  * -ENOMEM no memory to perform the operation
1880  *
1881  * @param driver the gadget driver
1882  * @return <0 if error, 0 if everything is fine
1883  */
1884 static int musb_gadget_start(struct usb_gadget *g,
1885                 struct usb_gadget_driver *driver)
1886 {
1887         struct musb             *musb = gadget_to_musb(g);
1888         struct usb_otg          *otg = musb->xceiv->otg;
1889         unsigned long           flags;
1890         int                     retval = 0;
1891
1892         if (driver->max_speed < USB_SPEED_HIGH) {
1893                 retval = -EINVAL;
1894                 goto err;
1895         }
1896
1897         pm_runtime_get_sync(musb->controller);
1898
1899         musb->softconnect = 0;
1900         musb->gadget_driver = driver;
1901
1902         spin_lock_irqsave(&musb->lock, flags);
1903         musb->is_active = 1;
1904
1905         otg_set_peripheral(otg, &musb->g);
1906         musb->xceiv->otg->state = OTG_STATE_B_IDLE;
1907         spin_unlock_irqrestore(&musb->lock, flags);
1908
1909         musb_start(musb);
1910
1911         /* REVISIT:  funcall to other code, which also
1912          * handles power budgeting ... this way also
1913          * ensures HdrcStart is indirectly called.
1914          */
1915         if (musb->xceiv->last_event == USB_EVENT_ID)
1916                 musb_platform_set_vbus(musb, 1);
1917
1918         if (musb->xceiv->last_event == USB_EVENT_NONE)
1919                 pm_runtime_put(musb->controller);
1920
1921         return 0;
1922
1923 err:
1924         return retval;
1925 }
1926
1927 /*
1928  * Unregister the gadget driver. Used by gadget drivers when
1929  * unregistering themselves from the controller.
1930  *
1931  * @param driver the gadget driver to unregister
1932  */
1933 static int musb_gadget_stop(struct usb_gadget *g)
1934 {
1935         struct musb     *musb = gadget_to_musb(g);
1936         unsigned long   flags;
1937
1938         if (musb->xceiv->last_event == USB_EVENT_NONE)
1939                 pm_runtime_get_sync(musb->controller);
1940
1941         /*
1942          * REVISIT always use otg_set_peripheral() here too;
1943          * this needs to shut down the OTG engine.
1944          */
1945
1946         spin_lock_irqsave(&musb->lock, flags);
1947
1948         musb_hnp_stop(musb);
1949
1950         (void) musb_gadget_vbus_draw(&musb->g, 0);
1951
1952         musb->xceiv->otg->state = OTG_STATE_UNDEFINED;
1953         musb_stop(musb);
1954         otg_set_peripheral(musb->xceiv->otg, NULL);
1955
1956         musb->is_active = 0;
1957         musb->gadget_driver = NULL;
1958         musb_platform_try_idle(musb, 0);
1959         spin_unlock_irqrestore(&musb->lock, flags);
1960
1961         /*
1962          * FIXME we need to be able to register another
1963          * gadget driver here and have everything work;
1964          * that currently misbehaves.
1965          */
1966
1967         pm_runtime_put(musb->controller);
1968
1969         return 0;
1970 }
1971
1972 /* ----------------------------------------------------------------------- */
1973
1974 /* lifecycle operations called through plat_uds.c */
1975
1976 void musb_g_resume(struct musb *musb)
1977 {
1978         musb->is_suspended = 0;
1979         switch (musb->xceiv->otg->state) {
1980         case OTG_STATE_B_IDLE:
1981                 break;
1982         case OTG_STATE_B_WAIT_ACON:
1983         case OTG_STATE_B_PERIPHERAL:
1984                 musb->is_active = 1;
1985                 if (musb->gadget_driver && musb->gadget_driver->resume) {
1986                         spin_unlock(&musb->lock);
1987                         musb->gadget_driver->resume(&musb->g);
1988                         spin_lock(&musb->lock);
1989                 }
1990                 break;
1991         default:
1992                 WARNING("unhandled RESUME transition (%s)\n",
1993                                 usb_otg_state_string(musb->xceiv->otg->state));
1994         }
1995 }
1996
1997 /* called when SOF packets stop for 3+ msec */
1998 void musb_g_suspend(struct musb *musb)
1999 {
2000         u8      devctl;
2001
2002         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
2003         dev_dbg(musb->controller, "devctl %02x\n", devctl);
2004
2005         switch (musb->xceiv->otg->state) {
2006         case OTG_STATE_B_IDLE:
2007                 if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
2008                         musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
2009                 break;
2010         case OTG_STATE_B_PERIPHERAL:
2011                 musb->is_suspended = 1;
2012                 if (musb->gadget_driver && musb->gadget_driver->suspend) {
2013                         spin_unlock(&musb->lock);
2014                         musb->gadget_driver->suspend(&musb->g);
2015                         spin_lock(&musb->lock);
2016                 }
2017                 break;
2018         default:
2019                 /* REVISIT if B_HOST, clear DEVCTL.HOSTREQ;
2020                  * A_PERIPHERAL may need care too
2021                  */
2022                 WARNING("unhandled SUSPEND transition (%s)\n",
2023                                 usb_otg_state_string(musb->xceiv->otg->state));
2024         }
2025 }
2026
2027 /* Called during SRP */
2028 void musb_g_wakeup(struct musb *musb)
2029 {
2030         musb_gadget_wakeup(&musb->g);
2031 }
2032
2033 /* called when VBUS drops below session threshold, and in other cases */
2034 void musb_g_disconnect(struct musb *musb)
2035 {
2036         void __iomem    *mregs = musb->mregs;
2037         u8      devctl = musb_readb(mregs, MUSB_DEVCTL);
2038
2039         dev_dbg(musb->controller, "devctl %02x\n", devctl);
2040
2041         /* clear HR */
2042         musb_writeb(mregs, MUSB_DEVCTL, devctl & MUSB_DEVCTL_SESSION);
2043
2044         /* don't draw vbus until new b-default session */
2045         (void) musb_gadget_vbus_draw(&musb->g, 0);
2046
2047         musb->g.speed = USB_SPEED_UNKNOWN;
2048         if (musb->gadget_driver && musb->gadget_driver->disconnect) {
2049                 spin_unlock(&musb->lock);
2050                 musb->gadget_driver->disconnect(&musb->g);
2051                 spin_lock(&musb->lock);
2052         }
2053
2054         switch (musb->xceiv->otg->state) {
2055         default:
2056                 dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n",
2057                         usb_otg_state_string(musb->xceiv->otg->state));
2058                 musb->xceiv->otg->state = OTG_STATE_A_IDLE;
2059                 MUSB_HST_MODE(musb);
2060                 break;
2061         case OTG_STATE_A_PERIPHERAL:
2062                 musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON;
2063                 MUSB_HST_MODE(musb);
2064                 break;
2065         case OTG_STATE_B_WAIT_ACON:
2066         case OTG_STATE_B_HOST:
2067         case OTG_STATE_B_PERIPHERAL:
2068         case OTG_STATE_B_IDLE:
2069                 musb->xceiv->otg->state = OTG_STATE_B_IDLE;
2070                 break;
2071         case OTG_STATE_B_SRP_INIT:
2072                 break;
2073         }
2074
2075         musb->is_active = 0;
2076 }
2077
2078 void musb_g_reset(struct musb *musb)
2079 __releases(musb->lock)
2080 __acquires(musb->lock)
2081 {
2082         void __iomem    *mbase = musb->mregs;
2083         u8              devctl = musb_readb(mbase, MUSB_DEVCTL);
2084         u8              power;
2085
2086         dev_dbg(musb->controller, "<== %s driver '%s'\n",
2087                         (devctl & MUSB_DEVCTL_BDEVICE)
2088                                 ? "B-Device" : "A-Device",
2089                         musb->gadget_driver
2090                                 ? musb->gadget_driver->driver.name
2091                                 : NULL
2092                         );
2093
2094         /* report reset, if we didn't already (flushing EP state) */
2095         if (musb->gadget_driver && musb->g.speed != USB_SPEED_UNKNOWN) {
2096                 spin_unlock(&musb->lock);
2097                 usb_gadget_udc_reset(&musb->g, musb->gadget_driver);
2098                 spin_lock(&musb->lock);
2099         }
2100
2101         /* clear HR */
2102         else if (devctl & MUSB_DEVCTL_HR)
2103                 musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
2104
2105
2106         /* what speed did we negotiate? */
2107         power = musb_readb(mbase, MUSB_POWER);
2108         musb->g.speed = (power & MUSB_POWER_HSMODE)
2109                         ? USB_SPEED_HIGH : USB_SPEED_FULL;
2110
2111         /* start in USB_STATE_DEFAULT */
2112         musb->is_active = 1;
2113         musb->is_suspended = 0;
2114         MUSB_DEV_MODE(musb);
2115         musb->address = 0;
2116         musb->ep0_state = MUSB_EP0_STAGE_SETUP;
2117
2118         musb->may_wakeup = 0;
2119         musb->g.b_hnp_enable = 0;
2120         musb->g.a_alt_hnp_support = 0;
2121         musb->g.a_hnp_support = 0;
2122         musb->g.quirk_zlp_not_supp = 1;
2123
2124         /* Normal reset, as B-Device;
2125          * or else after HNP, as A-Device
2126          */
2127         if (!musb->g.is_otg) {
2128                 /* USB device controllers that are not OTG compatible
2129                  * may not have DEVCTL register in silicon.
2130                  * In that case, do not rely on devctl for setting
2131                  * peripheral mode.
2132                  */
2133                 musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
2134                 musb->g.is_a_peripheral = 0;
2135         } else if (devctl & MUSB_DEVCTL_BDEVICE) {
2136                 musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL;
2137                 musb->g.is_a_peripheral = 0;
2138         } else {
2139                 musb->xceiv->otg->state = OTG_STATE_A_PERIPHERAL;
2140                 musb->g.is_a_peripheral = 1;
2141         }
2142
2143         /* start with default limits on VBUS power draw */
2144         (void) musb_gadget_vbus_draw(&musb->g, 8);
2145 }