drivers/usb/gadget/udc/aspeed-vhub/epn.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget
   4  *
   5  * epn.c - Generic endpoints management
   6  *
   7  * Copyright 2017 IBM Corporation
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/delay.h>
  14 #include <linux/ioport.h>
  15 #include <linux/slab.h>
  16 #include <linux/errno.h>
  17 #include <linux/list.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/proc_fs.h>
  20 #include <linux/prefetch.h>
  21 #include <linux/clk.h>
  22 #include <linux/usb/gadget.h>
  23 #include <linux/of.h>
  24 #include <linux/of_gpio.h>
  25 #include <linux/regmap.h>
  26 #include <linux/dma-mapping.h>
  27
  28 #include "vhub.h"
  29
  30 #define EXTRA_CHECKS
  31
  32 #ifdef EXTRA_CHECKS
  33 #define CHECK(ep, expr, fmt...)                                 \
  34         do {                                                    \
  35                 if (!(expr)) EPDBG(ep, "CHECK:" fmt);           \
  36         } while(0)
  37 #else
  38 #define CHECK(ep, expr, fmt...) do { } while(0)
  39 #endif
  40
  41 static void ast_vhub_epn_kick(struct ast_vhub_ep *ep, struct ast_vhub_req *req)
  42 {
  43         unsigned int act = req->req.actual;
  44         unsigned int len = req->req.length;
  45         unsigned int chunk;
  46
  47         /* There should be no DMA ongoing */
  48         WARN_ON(req->active);
  49
  50         /* Calculate next chunk size */
  51         chunk = len - act;
  52         if (chunk > ep->ep.maxpacket)
  53                 chunk = ep->ep.maxpacket;
  54         else if ((chunk < ep->ep.maxpacket) || !req->req.zero)
  55                 req->last_desc = 1;
  56
  57         EPVDBG(ep, "kick req %p act=%d/%d chunk=%d last=%d\n",
  58                req, act, len, chunk, req->last_desc);
  59
  60         /* If DMA unavailable, using staging EP buffer */
  61         if (!req->req.dma) {
  62
  63                 /* For IN transfers, copy data over first */
  64                 if (ep->epn.is_in) {
  65                         memcpy(ep->buf, req->req.buf + act, chunk);
  66                         vhub_dma_workaround(ep->buf);
  67                 }
  68                 writel(ep->buf_dma, ep->epn.regs + AST_VHUB_EP_DESC_BASE);
  69         } else {
  70                 if (ep->epn.is_in)
  71                         vhub_dma_workaround(req->req.buf);
  72                 writel(req->req.dma + act, ep->epn.regs + AST_VHUB_EP_DESC_BASE);
  73         }
  74
  75         /* Start DMA */
  76         req->active = true;
  77         writel(VHUB_EP_DMA_SET_TX_SIZE(chunk),
  78                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
  79         writel(VHUB_EP_DMA_SET_TX_SIZE(chunk) | VHUB_EP_DMA_SINGLE_KICK,
  80                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
  81 }
  82
  83 static void ast_vhub_epn_handle_ack(struct ast_vhub_ep *ep)
  84 {
  85         struct ast_vhub_req *req;
  86         unsigned int len;
  87         u32 stat;
  88
  89         /* Read EP status */
  90         stat = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
  91
  92         /* Grab current request if any */
  93         req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req, queue);
  94
  95         EPVDBG(ep, "ACK status=%08x is_in=%d, req=%p (active=%d)\n",
  96                stat, ep->epn.is_in, req, req ? req->active : 0);
  97
  98         /* In absence of a request, bail out, must have been dequeued */
  99         if (!req)
 100                 return;
 101
 102         /*
 103          * Request not active, move on to processing queue, active request
 104          * was probably dequeued
 105          */
 106         if (!req->active)
 107                 goto next_chunk;
 108
 109         /* Check if HW has moved on */
 110         if (VHUB_EP_DMA_RPTR(stat) != 0) {
 111                 EPDBG(ep, "DMA read pointer not 0 !\n");
 112                 return;
 113         }
 114
 115         /* No current DMA ongoing */
 116         req->active = false;
 117
 118         /* Grab length out of HW */
 119         len = VHUB_EP_DMA_TX_SIZE(stat);
 120
 121         /* If not using DMA, copy data out if needed */
 122         if (!req->req.dma && !ep->epn.is_in && len)
 123                 memcpy(req->req.buf + req->req.actual, ep->buf, len);
 124
 125         /* Adjust size */
 126         req->req.actual += len;
 127
 128         /* Check for short packet */
 129         if (len < ep->ep.maxpacket)
 130                 req->last_desc = 1;
 131
 132         /* That's it ? complete the request and pick a new one */
 133         if (req->last_desc >= 0) {
 134                 ast_vhub_done(ep, req, 0);
 135                 req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req,
 136                                                queue);
 137
 138                 /*
 139                  * Due to lock dropping inside "done" the next request could
 140                  * already be active, so check for that and bail if needed.
 141                  */
 142                 if (!req || req->active)
 143                         return;
 144         }
 145
 146  next_chunk:
 147         ast_vhub_epn_kick(ep, req);
 148 }
 149
 150 static inline unsigned int ast_vhub_count_free_descs(struct ast_vhub_ep *ep)
 151 {
 152         /*
 153          * d_next == d_last means descriptor list empty to HW,
 154          * thus we can only have AST_VHUB_DESCS_COUNT-1 descriptors
 155          * in the list
 156          */
 157         return (ep->epn.d_last + AST_VHUB_DESCS_COUNT - ep->epn.d_next - 1) &
 158                 (AST_VHUB_DESCS_COUNT - 1);
 159 }
 160
 161 static void ast_vhub_epn_kick_desc(struct ast_vhub_ep *ep,
 162                                    struct ast_vhub_req *req)
 163 {
 164         struct ast_vhub_desc *desc = NULL;
 165         unsigned int act = req->act_count;
 166         unsigned int len = req->req.length;
 167         unsigned int chunk;
 168
 169         /* Mark request active if not already */
 170         req->active = true;
 171
 172         /* If the request was already completely written, do nothing */
 173         if (req->last_desc >= 0)
 174                 return;
 175
 176         EPVDBG(ep, "kick act=%d/%d chunk_max=%d free_descs=%d\n",
 177                act, len, ep->epn.chunk_max, ast_vhub_count_free_descs(ep));
 178
 179         /* While we can create descriptors */
 180         while (ast_vhub_count_free_descs(ep) && req->last_desc < 0) {
 181                 unsigned int d_num;
 182
 183                 /* Grab next free descriptor */
 184                 d_num = ep->epn.d_next;
 185                 desc = &ep->epn.descs[d_num];
 186                 ep->epn.d_next = (d_num + 1) & (AST_VHUB_DESCS_COUNT - 1);
 187
 188                 /* Calculate next chunk size */
 189                 chunk = len - act;
 190                 if (chunk <= ep->epn.chunk_max) {
 191                         /*
 192                          * Is this the last packet ? Because of having up to 8
 193                          * packets in a descriptor we can't just compare "chunk"
 194                          * with ep.maxpacket. We have to see if it's a multiple
 195                          * of it to know if we have to send a zero packet.
 196                          * Sadly that involves a modulo which is a bit expensive
 197                          * but probably still better than not doing it.
 198                          */
 199                         if (!chunk || !req->req.zero || (chunk % ep->ep.maxpacket) != 0)
 200                                 req->last_desc = d_num;
 201                 } else {
 202                         chunk = ep->epn.chunk_max;
 203                 }
 204
 205                 EPVDBG(ep, " chunk: act=%d/%d chunk=%d last=%d desc=%d free=%d\n",
 206                        act, len, chunk, req->last_desc, d_num,
 207                        ast_vhub_count_free_descs(ep));
 208
 209                 /* Populate descriptor */
 210                 desc->w0 = cpu_to_le32(req->req.dma + act);
 211
 212                 /* Interrupt if end of request or no more descriptors */
 213
 214                 /*
 215                  * TODO: Be smarter about it, if we don't have enough
 216                  * descriptors request an interrupt before queue empty
 217                  * or so in order to be able to populate more before
 218                  * the HW runs out. This isn't a problem at the moment
 219                  * as we use 256 descriptors and only put at most one
 220                  * request in the ring.
 221                  */
 222                 desc->w1 = cpu_to_le32(VHUB_DSC1_IN_SET_LEN(chunk));
 223                 if (req->last_desc >= 0 || !ast_vhub_count_free_descs(ep))
 224                         desc->w1 |= cpu_to_le32(VHUB_DSC1_IN_INTERRUPT);
 225
 226                 /* Account packet */
 227                 req->act_count = act = act + chunk;
 228         }
 229
 230         if (likely(desc))
 231                 vhub_dma_workaround(desc);
 232
 233         /* Tell HW about new descriptors */
 234         writel(VHUB_EP_DMA_SET_CPU_WPTR(ep->epn.d_next),
 235                ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 236
 237         EPVDBG(ep, "HW kicked, d_next=%d dstat=%08x\n",
 238                ep->epn.d_next, readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS));
 239 }
 240
 241 static void ast_vhub_epn_handle_ack_desc(struct ast_vhub_ep *ep)
 242 {
 243         struct ast_vhub_req *req;
 244         unsigned int len, d_last;
 245         u32 stat, stat1;
 246
 247         /* Read EP status, workaround HW race */
 248         do {
 249                 stat = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 250                 stat1 = readl(ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 251         } while(stat != stat1);
 252
 253         /* Extract RPTR */
 254         d_last = VHUB_EP_DMA_RPTR(stat);
 255
 256         /* Grab current request if any */
 257         req = list_first_entry_or_null(&ep->queue, struct ast_vhub_req, queue);
 258
 259         EPVDBG(ep, "ACK status=%08x is_in=%d ep->d_last=%d..%d\n",
 260                stat, ep->epn.is_in, ep->epn.d_last, d_last);
 261
 262         /* Check all completed descriptors */
 263         while (ep->epn.d_last != d_last) {
 264                 struct ast_vhub_desc *desc;
 265                 unsigned int d_num;
 266                 bool is_last_desc;
 267
 268                 /* Grab next completed descriptor */
 269                 d_num = ep->epn.d_last;
 270                 desc = &ep->epn.descs[d_num];
 271                 ep->epn.d_last = (d_num + 1) & (AST_VHUB_DESCS_COUNT - 1);
 272
 273                 /* Grab len out of descriptor */
 274                 len = VHUB_DSC1_IN_LEN(le32_to_cpu(desc->w1));
 275
 276                 EPVDBG(ep, " desc %d len=%d req=%p (act=%d)\n",
 277                        d_num, len, req, req ? req->active : 0);
 278
 279                 /* If no active request pending, move on */
 280                 if (!req || !req->active)
 281                         continue;
 282
 283                 /* Adjust size */
 284                 req->req.actual += len;
 285
 286                 /* Is that the last chunk ? */
 287                 is_last_desc = req->last_desc == d_num;
 288                 CHECK(ep, is_last_desc == (len < ep->ep.maxpacket ||
 289                                            (req->req.actual >= req->req.length &&
 290                                             !req->req.zero)),
 291                       "Last packet discrepancy: last_desc=%d len=%d r.act=%d "
 292                       "r.len=%d r.zero=%d mp=%d\n",
 293                       is_last_desc, len, req->req.actual, req->req.length,
 294                       req->req.zero, ep->ep.maxpacket);
 295
 296                 if (is_last_desc) {
 297                         /*
 298                          * Because we can only have one request at a time
 299                          * in our descriptor list in this implementation,
 300                          * d_last and ep->d_last should now be equal
 301                          */
 302                         CHECK(ep, d_last == ep->epn.d_last,
 303                               "DMA read ptr mismatch %d vs %d\n",
 304                               d_last, ep->epn.d_last);
 305
 306                         /* Note: done will drop and re-acquire the lock */
 307                         ast_vhub_done(ep, req, 0);
 308                         req = list_first_entry_or_null(&ep->queue,
 309                                                        struct ast_vhub_req,
 310                                                        queue);
 311                         break;
 312                 }
 313         }
 314
 315         /* More work ? */
 316         if (req)
 317                 ast_vhub_epn_kick_desc(ep, req);
 318 }
 319
 320 void ast_vhub_epn_ack_irq(struct ast_vhub_ep *ep)
 321 {
 322         if (ep->epn.desc_mode)
 323                 ast_vhub_epn_handle_ack_desc(ep);
 324         else
 325                 ast_vhub_epn_handle_ack(ep);
 326 }
 327
 328 static int ast_vhub_epn_queue(struct usb_ep* u_ep, struct usb_request *u_req,
 329                               gfp_t gfp_flags)
 330 {
 331         struct ast_vhub_req *req = to_ast_req(u_req);
 332         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 333         struct ast_vhub *vhub = ep->vhub;
 334         unsigned long flags;
 335         bool empty;
 336         int rc;
 337
 338         /* Paranoid checks */
 339         if (!u_req || !u_req->complete || !u_req->buf) {
 340                 dev_warn(&vhub->pdev->dev, "Bogus EPn request ! u_req=%p\n", u_req);
 341                 if (u_req) {
 342                         dev_warn(&vhub->pdev->dev, "complete=%p internal=%d\n",
 343                                  u_req->complete, req->internal);
 344                 }
 345                 return -EINVAL;
 346         }
 347
 348         /* Endpoint enabled ? */
 349         if (!ep->epn.enabled || !u_ep->desc || !ep->dev || !ep->d_idx ||
 350             !ep->dev->enabled) {
 351                 EPDBG(ep, "Enqueuing request on wrong or disabled EP\n");
 352                 return -ESHUTDOWN;
 353         }
 354
 355         /* Map request for DMA if possible. For now, the rule for DMA is
 356          * that:
 357          *
 358          *  * For single stage mode (no descriptors):
 359          *
 360          *   - The buffer is aligned to a 8 bytes boundary (HW requirement)
 361          *   - For a OUT endpoint, the request size is a multiple of the EP
 362          *     packet size (otherwise the controller will DMA past the end
 363          *     of the buffer if the host is sending a too long packet).
 364          *
 365          *  * For descriptor mode (tx only for now), always.
 366          *
 367          * We could relax the latter by making the decision to use the bounce
 368          * buffer based on the size of a given *segment* of the request rather
 369          * than the whole request.
 370          */
 371         if (ep->epn.desc_mode ||
 372             ((((unsigned long)u_req->buf & 7) == 0) &&
 373              (ep->epn.is_in || !(u_req->length & (u_ep->maxpacket - 1))))) {
 374                 rc = usb_gadget_map_request_by_dev(&vhub->pdev->dev, u_req,
 375                                             ep->epn.is_in);
 376                 if (rc) {
 377                         dev_warn(&vhub->pdev->dev,
 378                                  "Request mapping failure %d\n", rc);
 379                         return rc;
 380                 }
 381         } else
 382                 u_req->dma = 0;
 383
 384         EPVDBG(ep, "enqueue req @%p\n", req);
 385         EPVDBG(ep, " l=%d dma=0x%x zero=%d noshort=%d noirq=%d is_in=%d\n",
 386                u_req->length, (u32)u_req->dma, u_req->zero,
 387                u_req->short_not_ok, u_req->no_interrupt,
 388                ep->epn.is_in);
 389
 390         /* Initialize request progress fields */
 391         u_req->status = -EINPROGRESS;
 392         u_req->actual = 0;
 393         req->act_count = 0;
 394         req->active = false;
 395         req->last_desc = -1;
 396         spin_lock_irqsave(&vhub->lock, flags);
 397         empty = list_empty(&ep->queue);
 398
 399         /* Add request to list and kick processing if empty */
 400         list_add_tail(&req->queue, &ep->queue);
 401         if (empty) {
 402                 if (ep->epn.desc_mode)
 403                         ast_vhub_epn_kick_desc(ep, req);
 404                 else
 405                         ast_vhub_epn_kick(ep, req);
 406         }
 407         spin_unlock_irqrestore(&vhub->lock, flags);
 408
 409         return 0;
 410 }
 411
 412 static void ast_vhub_stop_active_req(struct ast_vhub_ep *ep,
 413                                      bool restart_ep)
 414 {
 415         u32 state, reg, loops;
 416
 417         /* Stop DMA activity */
 418         if (ep->epn.desc_mode)
 419                 writel(VHUB_EP_DMA_CTRL_RESET, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 420         else
 421                 writel(0, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 422
 423         /* Wait for it to complete */
 424         for (loops = 0; loops < 1000; loops++) {
 425                 state = readl(ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 426                 state = VHUB_EP_DMA_PROC_STATUS(state);
 427                 if (state == EP_DMA_PROC_RX_IDLE ||
 428                     state == EP_DMA_PROC_TX_IDLE)
 429                         break;
 430                 udelay(1);
 431         }
 432         if (loops >= 1000)
 433                 dev_warn(&ep->vhub->pdev->dev, "Timeout waiting for DMA\n");
 434
 435         /* If we don't have to restart the endpoint, that's it */
 436         if (!restart_ep)
 437                 return;
 438
 439         /* Restart the endpoint */
 440         if (ep->epn.desc_mode) {
 441                 /*
 442                  * Take out descriptors by resetting the DMA read
 443                  * pointer to be equal to the CPU write pointer.
 444                  *
 445                  * Note: If we ever support creating descriptors for
 446                  * requests that aren't the head of the queue, we
 447                  * may have to do something more complex here,
 448                  * especially if the request being taken out is
 449                  * not the current head descriptors.
 450                  */
 451                 reg = VHUB_EP_DMA_SET_RPTR(ep->epn.d_next) |
 452                         VHUB_EP_DMA_SET_CPU_WPTR(ep->epn.d_next);
 453                 writel(reg, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 454
 455                 /* Then turn it back on */
 456                 writel(ep->epn.dma_conf,
 457                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 458         } else {
 459                 /* Single mode: just turn it back on */
 460                 writel(ep->epn.dma_conf,
 461                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 462         }
 463 }
 464
 465 static int ast_vhub_epn_dequeue(struct usb_ep* u_ep, struct usb_request *u_req)
 466 {
 467         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 468         struct ast_vhub *vhub = ep->vhub;
 469         struct ast_vhub_req *req;
 470         unsigned long flags;
 471         int rc = -EINVAL;
 472
 473         spin_lock_irqsave(&vhub->lock, flags);
 474
 475         /* Make sure it's actually queued on this endpoint */
 476         list_for_each_entry (req, &ep->queue, queue) {
 477                 if (&req->req == u_req)
 478                         break;
 479         }
 480
 481         if (&req->req == u_req) {
 482                 EPVDBG(ep, "dequeue req @%p active=%d\n",
 483                        req, req->active);
 484                 if (req->active)
 485                         ast_vhub_stop_active_req(ep, true);
 486                 ast_vhub_done(ep, req, -ECONNRESET);
 487                 rc = 0;
 488         }
 489
 490         spin_unlock_irqrestore(&vhub->lock, flags);
 491         return rc;
 492 }
 493
 494 void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep)
 495 {
 496         u32 reg;
 497
 498         if (WARN_ON(ep->d_idx == 0))
 499                 return;
 500         reg = readl(ep->epn.regs + AST_VHUB_EP_CONFIG);
 501         if (ep->epn.stalled || ep->epn.wedged)
 502                 reg |= VHUB_EP_CFG_STALL_CTRL;
 503         else
 504                 reg &= ~VHUB_EP_CFG_STALL_CTRL;
 505         writel(reg, ep->epn.regs + AST_VHUB_EP_CONFIG);
 506
 507         if (!ep->epn.stalled && !ep->epn.wedged)
 508                 writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
 509                        ep->vhub->regs + AST_VHUB_EP_TOGGLE);
 510 }
 511
 512 static int ast_vhub_set_halt_and_wedge(struct usb_ep* u_ep, bool halt,
 513                                       bool wedge)
 514 {
 515         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 516         struct ast_vhub *vhub = ep->vhub;
 517         unsigned long flags;
 518
 519         EPDBG(ep, "Set halt (%d) & wedge (%d)\n", halt, wedge);
 520
 521         if (!u_ep || !u_ep->desc)
 522                 return -EINVAL;
 523         if (ep->d_idx == 0)
 524                 return 0;
 525         if (ep->epn.is_iso)
 526                 return -EOPNOTSUPP;
 527
 528         spin_lock_irqsave(&vhub->lock, flags);
 529
 530         /* Fail with still-busy IN endpoints */
 531         if (halt && ep->epn.is_in && !list_empty(&ep->queue)) {
 532                 spin_unlock_irqrestore(&vhub->lock, flags);
 533                 return -EAGAIN;
 534         }
 535         ep->epn.stalled = halt;
 536         ep->epn.wedged = wedge;
 537         ast_vhub_update_epn_stall(ep);
 538
 539         spin_unlock_irqrestore(&vhub->lock, flags);
 540
 541         return 0;
 542 }
 543
 544 static int ast_vhub_epn_set_halt(struct usb_ep *u_ep, int value)
 545 {
 546         return ast_vhub_set_halt_and_wedge(u_ep, value != 0, false);
 547 }
 548
 549 static int ast_vhub_epn_set_wedge(struct usb_ep *u_ep)
 550 {
 551         return ast_vhub_set_halt_and_wedge(u_ep, true, true);
 552 }
 553
 554 static int ast_vhub_epn_disable(struct usb_ep* u_ep)
 555 {
 556         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 557         struct ast_vhub *vhub = ep->vhub;
 558         unsigned long flags;
 559         u32 imask, ep_ier;
 560
 561         EPDBG(ep, "Disabling !\n");
 562
 563         spin_lock_irqsave(&vhub->lock, flags);
 564
 565         ep->epn.enabled = false;
 566
 567         /* Stop active DMA if any */
 568         ast_vhub_stop_active_req(ep, false);
 569
 570         /* Disable endpoint */
 571         writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
 572
 573         /* Disable ACK interrupt */
 574         imask = VHUB_EP_IRQ(ep->epn.g_idx);
 575         ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
 576         ep_ier &= ~imask;
 577         writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
 578         writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
 579
 580         /* Nuke all pending requests */
 581         ast_vhub_nuke(ep, -ESHUTDOWN);
 582
 583         /* No more descriptor associated with request */
 584         ep->ep.desc = NULL;
 585
 586         spin_unlock_irqrestore(&vhub->lock, flags);
 587
 588         return 0;
 589 }
 590
 591 static int ast_vhub_epn_enable(struct usb_ep* u_ep,
 592                                const struct usb_endpoint_descriptor *desc)
 593 {
 594         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 595         struct ast_vhub_dev *dev;
 596         struct ast_vhub *vhub;
 597         u16 maxpacket, type;
 598         unsigned long flags;
 599         u32 ep_conf, ep_ier, imask;
 600
 601         /* Check arguments */
 602         if (!u_ep || !desc)
 603                 return -EINVAL;
 604
 605         maxpacket = usb_endpoint_maxp(desc);
 606         if (!ep->d_idx || !ep->dev ||
 607             desc->bDescriptorType != USB_DT_ENDPOINT ||
 608             maxpacket == 0 || maxpacket > ep->ep.maxpacket) {
 609                 EPDBG(ep, "Invalid EP enable,d_idx=%d,dev=%p,type=%d,mp=%d/%d\n",
 610                       ep->d_idx, ep->dev, desc->bDescriptorType,
 611                       maxpacket, ep->ep.maxpacket);
 612                 return -EINVAL;
 613         }
 614         if (ep->d_idx != usb_endpoint_num(desc)) {
 615                 EPDBG(ep, "EP number mismatch !\n");
 616                 return -EINVAL;
 617         }
 618
 619         if (ep->epn.enabled) {
 620                 EPDBG(ep, "Already enabled\n");
 621                 return -EBUSY;
 622         }
 623         dev = ep->dev;
 624         vhub = ep->vhub;
 625
 626         /* Check device state */
 627         if (!dev->driver) {
 628                 EPDBG(ep, "Bogus device state: driver=%p speed=%d\n",
 629                        dev->driver, dev->gadget.speed);
 630                 return -ESHUTDOWN;
 631         }
 632
 633         /* Grab some info from the descriptor */
 634         ep->epn.is_in = usb_endpoint_dir_in(desc);
 635         ep->ep.maxpacket = maxpacket;
 636         type = usb_endpoint_type(desc);
 637         ep->epn.d_next = ep->epn.d_last = 0;
 638         ep->epn.is_iso = false;
 639         ep->epn.stalled = false;
 640         ep->epn.wedged = false;
 641
 642         EPDBG(ep, "Enabling [%s] %s num %d maxpacket=%d\n",
 643               ep->epn.is_in ? "in" : "out", usb_ep_type_string(type),
 644               usb_endpoint_num(desc), maxpacket);
 645
 646         /* Can we use DMA descriptor mode ? */
 647         ep->epn.desc_mode = ep->epn.descs && ep->epn.is_in;
 648         if (ep->epn.desc_mode)
 649                 memset(ep->epn.descs, 0, 8 * AST_VHUB_DESCS_COUNT);
 650
 651         /*
 652          * Large send function can send up to 8 packets from
 653          * one descriptor with a limit of 4095 bytes.
 654          */
 655         ep->epn.chunk_max = ep->ep.maxpacket;
 656         if (ep->epn.is_in) {
 657                 ep->epn.chunk_max <<= 3;
 658                 while (ep->epn.chunk_max > 4095)
 659                         ep->epn.chunk_max -= ep->ep.maxpacket;
 660         }
 661
 662         switch(type) {
 663         case USB_ENDPOINT_XFER_CONTROL:
 664                 EPDBG(ep, "Only one control endpoint\n");
 665                 return -EINVAL;
 666         case USB_ENDPOINT_XFER_INT:
 667                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_INT);
 668                 break;
 669         case USB_ENDPOINT_XFER_BULK:
 670                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_BULK);
 671                 break;
 672         case USB_ENDPOINT_XFER_ISOC:
 673                 ep_conf = VHUB_EP_CFG_SET_TYPE(EP_TYPE_ISO);
 674                 ep->epn.is_iso = true;
 675                 break;
 676         default:
 677                 return -EINVAL;
 678         }
 679
 680         /* Encode the rest of the EP config register */
 681         if (maxpacket < 1024)
 682                 ep_conf |= VHUB_EP_CFG_SET_MAX_PKT(maxpacket);
 683         if (!ep->epn.is_in)
 684                 ep_conf |= VHUB_EP_CFG_DIR_OUT;
 685         ep_conf |= VHUB_EP_CFG_SET_EP_NUM(usb_endpoint_num(desc));
 686         ep_conf |= VHUB_EP_CFG_ENABLE;
 687         ep_conf |= VHUB_EP_CFG_SET_DEV(dev->index + 1);
 688         EPVDBG(ep, "config=%08x\n", ep_conf);
 689
 690         spin_lock_irqsave(&vhub->lock, flags);
 691
 692         /* Disable HW and reset DMA */
 693         writel(0, ep->epn.regs + AST_VHUB_EP_CONFIG);
 694         writel(VHUB_EP_DMA_CTRL_RESET,
 695                ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 696
 697         /* Configure and enable */
 698         writel(ep_conf, ep->epn.regs + AST_VHUB_EP_CONFIG);
 699
 700         if (ep->epn.desc_mode) {
 701                 /* Clear DMA status, including the DMA read ptr */
 702                 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 703
 704                 /* Set descriptor base */
 705                 writel(ep->epn.descs_dma,
 706                        ep->epn.regs + AST_VHUB_EP_DESC_BASE);
 707
 708                 /* Set base DMA config value */
 709                 ep->epn.dma_conf = VHUB_EP_DMA_DESC_MODE;
 710                 if (ep->epn.is_in)
 711                         ep->epn.dma_conf |= VHUB_EP_DMA_IN_LONG_MODE;
 712
 713                 /* First reset and disable all operations */
 714                 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
 715                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 716
 717                 /* Enable descriptor mode */
 718                 writel(ep->epn.dma_conf,
 719                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 720         } else {
 721                 /* Set base DMA config value */
 722                 ep->epn.dma_conf = VHUB_EP_DMA_SINGLE_STAGE;
 723
 724                 /* Reset and switch to single stage mode */
 725                 writel(ep->epn.dma_conf | VHUB_EP_DMA_CTRL_RESET,
 726                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 727                 writel(ep->epn.dma_conf,
 728                        ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT);
 729                 writel(0, ep->epn.regs + AST_VHUB_EP_DESC_STATUS);
 730         }
 731
 732         /* Cleanup data toggle just in case */
 733         writel(VHUB_EP_TOGGLE_SET_EPNUM(ep->epn.g_idx),
 734                vhub->regs + AST_VHUB_EP_TOGGLE);
 735
 736         /* Cleanup and enable ACK interrupt */
 737         imask = VHUB_EP_IRQ(ep->epn.g_idx);
 738         writel(imask, vhub->regs + AST_VHUB_EP_ACK_ISR);
 739         ep_ier = readl(vhub->regs + AST_VHUB_EP_ACK_IER);
 740         ep_ier |= imask;
 741         writel(ep_ier, vhub->regs + AST_VHUB_EP_ACK_IER);
 742
 743         /* Woot, we are online ! */
 744         ep->epn.enabled = true;
 745
 746         spin_unlock_irqrestore(&vhub->lock, flags);
 747
 748         return 0;
 749 }
 750
 751 static void ast_vhub_epn_dispose(struct usb_ep *u_ep)
 752 {
 753         struct ast_vhub_ep *ep = to_ast_ep(u_ep);
 754
 755         if (WARN_ON(!ep->dev || !ep->d_idx))
 756                 return;
 757
 758         EPDBG(ep, "Releasing endpoint\n");
 759
 760         /* Take it out of the EP list */
 761         list_del_init(&ep->ep.ep_list);
 762
 763         /* Mark the address free in the device */
 764         ep->dev->epns[ep->d_idx - 1] = NULL;
 765
 766         /* Free name & DMA buffers */
 767         kfree(ep->ep.name);
 768         ep->ep.name = NULL;
 769         dma_free_coherent(&ep->vhub->pdev->dev,
 770                           AST_VHUB_EPn_MAX_PACKET +
 771                           8 * AST_VHUB_DESCS_COUNT,
 772                           ep->buf, ep->buf_dma);
 773         ep->buf = NULL;
 774         ep->epn.descs = NULL;
 775
 776         /* Mark free */
 777         ep->dev = NULL;
 778 }
 779
 780 static const struct usb_ep_ops ast_vhub_epn_ops = {
 781         .enable         = ast_vhub_epn_enable,
 782         .disable        = ast_vhub_epn_disable,
 783         .dispose        = ast_vhub_epn_dispose,
 784         .queue          = ast_vhub_epn_queue,
 785         .dequeue        = ast_vhub_epn_dequeue,
 786         .set_halt       = ast_vhub_epn_set_halt,
 787         .set_wedge      = ast_vhub_epn_set_wedge,
 788         .alloc_request  = ast_vhub_alloc_request,
 789         .free_request   = ast_vhub_free_request,
 790 };
 791
 792 struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr)
 793 {
 794         struct ast_vhub *vhub = d->vhub;
 795         struct ast_vhub_ep *ep;
 796         unsigned long flags;
 797         int i;
 798
 799         /* Find a free one (no device) */
 800         spin_lock_irqsave(&vhub->lock, flags);
 801         for (i = 0; i < vhub->max_epns; i++)
 802                 if (vhub->epns[i].dev == NULL)
 803                         break;
 804         if (i >= vhub->max_epns) {
 805                 spin_unlock_irqrestore(&vhub->lock, flags);
 806                 return NULL;
 807         }
 808
 809         /* Set it up */
 810         ep = &vhub->epns[i];
 811         ep->dev = d;
 812         spin_unlock_irqrestore(&vhub->lock, flags);
 813
 814         DDBG(d, "Allocating gen EP %d for addr %d\n", i, addr);
 815         INIT_LIST_HEAD(&ep->queue);
 816         ep->d_idx = addr;
 817         ep->vhub = vhub;
 818         ep->ep.ops = &ast_vhub_epn_ops;
 819         ep->ep.name = kasprintf(GFP_KERNEL, "ep%d", addr);
 820         d->epns[addr-1] = ep;
 821         ep->epn.g_idx = i;
 822         ep->epn.regs = vhub->regs + 0x200 + (i * 0x10);
 823
 824         ep->buf = dma_alloc_coherent(&vhub->pdev->dev,
 825                                      AST_VHUB_EPn_MAX_PACKET +
 826                                      8 * AST_VHUB_DESCS_COUNT,
 827                                      &ep->buf_dma, GFP_KERNEL);
 828         if (!ep->buf) {
 829                 kfree(ep->ep.name);
 830                 ep->ep.name = NULL;
 831                 return NULL;
 832         }
 833         ep->epn.descs = ep->buf + AST_VHUB_EPn_MAX_PACKET;
 834         ep->epn.descs_dma = ep->buf_dma + AST_VHUB_EPn_MAX_PACKET;
 835
 836         usb_ep_set_maxpacket_limit(&ep->ep, AST_VHUB_EPn_MAX_PACKET);
 837         list_add_tail(&ep->ep.ep_list, &d->gadget.ep_list);
 838         ep->ep.caps.type_iso = true;
 839         ep->ep.caps.type_bulk = true;
 840         ep->ep.caps.type_int = true;
 841         ep->ep.caps.dir_in = true;
 842         ep->ep.caps.dir_out = true;
 843
 844         return ep;
 845 }