drivers/usb/host/ehci-sched.c

   1 /*
   2  * Copyright (c) 2001-2002 by David Brownell
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2 of the License, or (at your
   7  * option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 /* this file is part of ehci-hcd.c */
  20
  21 /*-------------------------------------------------------------------------*/
  22
  23 /*
  24  * EHCI scheduled transaction support:  interrupt, iso, split iso
  25  * These are called "periodic" transactions in the EHCI spec.
  26  *
  27  * Note that for interrupt transfers, the QH/QTD manipulation is shared
  28  * with the "asynchronous" transaction support (control/bulk transfers).
  29  * The only real difference is in how interrupt transfers are scheduled.
  30  * We get some funky API restrictions from the current URB model, which
  31  * works notably better for reading transfers than for writing.  (And
  32  * which accordingly needs to change before it'll work inside devices,
  33  * or with "USB On The Go" additions to USB 2.0 ...)
  34  */
  35
  36 static int ehci_get_frame (struct usb_hcd *hcd);
  37
  38 /*-------------------------------------------------------------------------*/
  39
  40 /*
  41  * periodic_next_shadow - return "next" pointer on shadow list
  42  * @periodic: host pointer to qh/itd/sitd
  43  * @tag: hardware tag for type of this record
  44  */
  45 static union ehci_shadow *
  46 periodic_next_shadow (union ehci_shadow *periodic, int tag)
  47 {
  48         switch (tag) {
  49         case Q_TYPE_QH:
  50                 return &periodic->qh->qh_next;
  51         case Q_TYPE_FSTN:
  52                 return &periodic->fstn->fstn_next;
  53         case Q_TYPE_ITD:
  54                 return &periodic->itd->itd_next;
  55 #ifdef have_split_iso
  56         case Q_TYPE_SITD:
  57                 return &periodic->sitd->sitd_next;
  58 #endif /* have_split_iso */
  59         }
  60         dbg ("BAD shadow %p tag %d", periodic->ptr, tag);
  61         // BUG ();
  62         return 0;
  63 }
  64
  65 /* returns true after successful unlink */
  66 /* caller must hold ehci->lock */
  67 static int periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
  68 {
  69         union ehci_shadow       *prev_p = &ehci->pshadow [frame];
  70         u32                     *hw_p = &ehci->periodic [frame];
  71         union ehci_shadow       here = *prev_p;
  72         union ehci_shadow       *next_p;
  73
  74         /* find predecessor of "ptr"; hw and shadow lists are in sync */
  75         while (here.ptr && here.ptr != ptr) {
  76                 prev_p = periodic_next_shadow (prev_p, Q_NEXT_TYPE (*hw_p));
  77                 hw_p = &here.qh->hw_next;
  78                 here = *prev_p;
  79         }
  80         /* an interrupt entry (at list end) could have been shared */
  81         if (!here.ptr) {
  82                 dbg ("entry %p no longer on frame [%d]", ptr, frame);
  83                 return 0;
  84         }
  85         // vdbg ("periodic unlink %p from frame %d", ptr, frame);
  86
  87         /* update hardware list ... HC may still know the old structure, so
  88          * don't change hw_next until it'll have purged its cache
  89          */
  90         next_p = periodic_next_shadow (&here, Q_NEXT_TYPE (*hw_p));
  91         *hw_p = here.qh->hw_next;
  92
  93         /* unlink from shadow list; HCD won't see old structure again */
  94         *prev_p = *next_p;
  95         next_p->ptr = 0;
  96
  97         return 1;
  98 }
  99
 100 /* how many of the uframe's 125 usecs are allocated? */
 101 static unsigned short
 102 periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
 103 {
 104         u32                     *hw_p = &ehci->periodic [frame];
 105         union ehci_shadow       *q = &ehci->pshadow [frame];
 106         unsigned                usecs = 0;
 107
 108         while (q->ptr) {
 109                 switch (Q_NEXT_TYPE (*hw_p)) {
 110                 case Q_TYPE_QH:
 111                         /* is it in the S-mask? */
 112                         if (q->qh->hw_info2 & cpu_to_le32 (1 << uframe))
 113                                 usecs += q->qh->usecs;
 114                         /* ... or C-mask? */
 115                         if (q->qh->hw_info2 & cpu_to_le32 (1 << (8 + uframe)))
 116                                 usecs += q->qh->c_usecs;
 117                         q = &q->qh->qh_next;
 118                         break;
 119                 case Q_TYPE_FSTN:
 120                         /* for "save place" FSTNs, count the relevant INTR
 121                          * bandwidth from the previous frame
 122                          */
 123                         if (q->fstn->hw_prev != EHCI_LIST_END) {
 124                                 dbg ("not counting FSTN bandwidth yet ...");
 125                         }
 126                         q = &q->fstn->fstn_next;
 127                         break;
 128                 case Q_TYPE_ITD:
 129                         /* NOTE the "one uframe per itd" policy */
 130                         if (q->itd->hw_transaction [uframe] != 0)
 131                                 usecs += q->itd->usecs;
 132                         q = &q->itd->itd_next;
 133                         break;
 134 #ifdef have_split_iso
 135                 case Q_TYPE_SITD:
 136                         temp = q->sitd->hw_fullspeed_ep &
 137                                 __constant_cpu_to_le32 (1 << 31);
 138
 139                         // FIXME:  this doesn't count data bytes right...
 140
 141                         /* is it in the S-mask?  (count SPLIT, DATA) */
 142                         if (q->sitd->hw_uframe & cpu_to_le32 (1 << uframe)) {
 143                                 if (temp)
 144                                         usecs += HS_USECS (188);
 145                                 else
 146                                         usecs += HS_USECS (1);
 147                         }
 148
 149                         /* ... C-mask?  (count CSPLIT, DATA) */
 150                         if (q->sitd->hw_uframe &
 151                                         cpu_to_le32 (1 << (8 + uframe))) {
 152                                 if (temp)
 153                                         usecs += HS_USECS (0);
 154                                 else
 155                                         usecs += HS_USECS (188);
 156                         }
 157                         q = &q->sitd->sitd_next;
 158                         break;
 159 #endif /* have_split_iso */
 160                 default:
 161                         BUG ();
 162                 }
 163         }
 164 #ifdef  DEBUG
 165         if (usecs > 100)
 166                 err ("overallocated uframe %d, periodic is %d usecs",
 167                         frame * 8 + uframe, usecs);
 168 #endif
 169         return usecs;
 170 }
 171
 172 /*-------------------------------------------------------------------------*/
 173
 174 static int enable_periodic (struct ehci_hcd *ehci)
 175 {
 176         u32     cmd;
 177         int     status;
 178
 179         /* did clearing PSE did take effect yet?
 180          * takes effect only at frame boundaries...
 181          */
 182         status = handshake (&ehci->regs->status, STS_PSS, 0, 9 * 125);
 183         if (status != 0) {
 184                 ehci->hcd.state = USB_STATE_HALT;
 185                 return status;
 186         }
 187
 188         cmd = readl (&ehci->regs->command) | CMD_PSE;
 189         writel (cmd, &ehci->regs->command);
 190         /* posted write ... PSS happens later */
 191         ehci->hcd.state = USB_STATE_RUNNING;
 192
 193         /* make sure ehci_work scans these */
 194         ehci->next_uframe = readl (&ehci->regs->frame_index)
 195                                 % (ehci->periodic_size << 3);
 196         return 0;
 197 }
 198
 199 static int disable_periodic (struct ehci_hcd *ehci)
 200 {
 201         u32     cmd;
 202         int     status;
 203
 204         /* did setting PSE not take effect yet?
 205          * takes effect only at frame boundaries...
 206          */
 207         status = handshake (&ehci->regs->status, STS_PSS, STS_PSS, 9 * 125);
 208         if (status != 0) {
 209                 ehci->hcd.state = USB_STATE_HALT;
 210                 return status;
 211         }
 212
 213         cmd = readl (&ehci->regs->command) & ~CMD_PSE;
 214         writel (cmd, &ehci->regs->command);
 215         /* posted write ... */
 216
 217         ehci->next_uframe = -1;
 218         return 0;
 219 }
 220
 221 /*-------------------------------------------------------------------------*/
 222
 223 // FIXME microframe periods not yet handled
 224
 225 static void intr_deschedule (
 226         struct ehci_hcd *ehci,
 227         struct ehci_qh  *qh,
 228         int             wait
 229 ) {
 230         int             status;
 231         unsigned        frame = qh->start;
 232
 233         do {
 234                 periodic_unlink (ehci, frame, qh);
 235                 qh_put (ehci, qh);
 236                 frame += qh->period;
 237         } while (frame < ehci->periodic_size);
 238
 239         qh->qh_state = QH_STATE_UNLINK;
 240         qh->qh_next.ptr = 0;
 241         ehci->periodic_sched--;
 242
 243         /* maybe turn off periodic schedule */
 244         if (!ehci->periodic_sched)
 245                 status = disable_periodic (ehci);
 246         else {
 247                 status = 0;
 248                 vdbg ("periodic schedule still enabled");
 249         }
 250
 251         /*
 252          * If the hc may be looking at this qh, then delay a uframe
 253          * (yeech!) to be sure it's done.
 254          * No other threads may be mucking with this qh.
 255          */
 256         if (((ehci_get_frame (&ehci->hcd) - frame) % qh->period) == 0) {
 257                 if (wait) {
 258                         udelay (125);
 259                         qh->hw_next = EHCI_LIST_END;
 260                 } else {
 261                         /* we may not be IDLE yet, but if the qh is empty
 262                          * the race is very short.  then if qh also isn't
 263                          * rescheduled soon, it won't matter.  otherwise...
 264                          */
 265                         vdbg ("intr_deschedule...");
 266                 }
 267         } else
 268                 qh->hw_next = EHCI_LIST_END;
 269
 270         qh->qh_state = QH_STATE_IDLE;
 271
 272         /* update per-qh bandwidth utilization (for usbfs) */
 273         hcd_to_bus (&ehci->hcd)->bandwidth_allocated -=
 274                 (qh->usecs + qh->c_usecs) / qh->period;
 275
 276         dbg ("descheduled qh %p, period = %d frame = %d count = %d, urbs = %d",
 277                 qh, qh->period, frame,
 278                 atomic_read (&qh->refcount), ehci->periodic_sched);
 279 }
 280
 281 static int check_period (
 282         struct ehci_hcd *ehci,
 283         unsigned        frame,
 284         unsigned        uframe,
 285         unsigned        period,
 286         unsigned        usecs
 287 ) {
 288         /* complete split running into next frame?
 289          * given FSTN support, we could sometimes check...
 290          */
 291         if (uframe >= 8)
 292                 return 0;
 293
 294         /*
 295          * 80% periodic == 100 usec/uframe available
 296          * convert "usecs we need" to "max already claimed"
 297          */
 298         usecs = 100 - usecs;
 299
 300         do {
 301                 int     claimed;
 302
 303 // FIXME delete when intr_submit handles non-empty queues
 304 // this gives us a one intr/frame limit (vs N/uframe)
 305 // ... and also lets us avoid tracking split transactions
 306 // that might collide at a given TT/hub.
 307                 if (ehci->pshadow [frame].ptr)
 308                         return 0;
 309
 310                 claimed = periodic_usecs (ehci, frame, uframe);
 311                 if (claimed > usecs)
 312                         return 0;
 313
 314 // FIXME update to handle sub-frame periods
 315         } while ((frame += period) < ehci->periodic_size);
 316
 317         // success!
 318         return 1;
 319 }
 320
 321 static int check_intr_schedule (
 322         struct ehci_hcd         *ehci,
 323         unsigned                frame,
 324         unsigned                uframe,
 325         const struct ehci_qh    *qh,
 326         u32                     *c_maskp
 327 )
 328 {
 329         int             retval = -ENOSPC;
 330
 331         if (!check_period (ehci, frame, uframe, qh->period, qh->usecs))
 332                 goto done;
 333         if (!qh->c_usecs) {
 334                 retval = 0;
 335                 *c_maskp = cpu_to_le32 (0);
 336                 goto done;
 337         }
 338
 339         /* This is a split transaction; check the bandwidth available for
 340          * the completion too.  Check both worst and best case gaps: worst
 341          * case is SPLIT near uframe end, and CSPLIT near start ... best is
 342          * vice versa.  Difference can be almost two uframe times, but we
 343          * reserve unnecessary bandwidth (waste it) this way.  (Actually
 344          * even better cases exist, like immediate device NAK.)
 345          *
 346          * FIXME don't even bother unless we know this TT is idle in that
 347          * range of uframes ... for now, check_period() allows only one
 348          * interrupt transfer per frame, so needn't check "TT busy" status
 349          * when scheduling a split (QH, SITD, or FSTN).
 350          *
 351          * FIXME ehci 0.96 and above can use FSTNs
 352          */
 353         if (!check_period (ehci, frame, uframe + qh->gap_uf + 1,
 354                                 qh->period, qh->c_usecs))
 355                 goto done;
 356         if (!check_period (ehci, frame, uframe + qh->gap_uf,
 357                                 qh->period, qh->c_usecs))
 358                 goto done;
 359
 360         *c_maskp = cpu_to_le32 (0x03 << (8 + uframe + qh->gap_uf));
 361         retval = 0;
 362 done:
 363         return retval;
 364 }
 365
 366 static int qh_schedule (struct ehci_hcd *ehci, struct ehci_qh *qh)
 367 {
 368         int             status;
 369         unsigned        uframe;
 370         u32             c_mask;
 371         unsigned        frame;          /* 0..(qh->period - 1), or NO_FRAME */
 372
 373         qh->hw_next = EHCI_LIST_END;
 374         frame = qh->start;
 375
 376         /* reuse the previous schedule slots, if we can */
 377         if (frame < qh->period) {
 378                 uframe = ffs (le32_to_cpup (&qh->hw_info2) & 0x00ff);
 379                 status = check_intr_schedule (ehci, frame, --uframe,
 380                                 qh, &c_mask);
 381         } else {
 382                 uframe = 0;
 383                 c_mask = 0;
 384                 status = -ENOSPC;
 385         }
 386
 387         /* else scan the schedule to find a group of slots such that all
 388          * uframes have enough periodic bandwidth available.
 389          */
 390         if (status) {
 391                 frame = qh->period - 1;
 392                 do {
 393                         for (uframe = 0; uframe < 8; uframe++) {
 394                                 status = check_intr_schedule (ehci,
 395                                                 frame, uframe, qh,
 396                                                 &c_mask);
 397                                 if (status == 0)
 398                                         break;
 399                         }
 400                 } while (status && --frame);
 401                 if (status)
 402                         goto done;
 403                 qh->start = frame;
 404
 405                 /* reset S-frame and (maybe) C-frame masks */
 406                 qh->hw_info2 &= ~0xffff;
 407                 qh->hw_info2 |= cpu_to_le32 (1 << uframe) | c_mask;
 408         } else
 409                 dbg ("reused previous qh %p schedule", qh);
 410
 411         /* stuff into the periodic schedule */
 412         qh->qh_state = QH_STATE_LINKED;
 413         dbg ("scheduled qh %p usecs %d/%d period %d.0 starting %d.%d (gap %d)",
 414                 qh, qh->usecs, qh->c_usecs,
 415                 qh->period, frame, uframe, qh->gap_uf);
 416         do {
 417                 if (unlikely (ehci->pshadow [frame].ptr != 0)) {
 418
 419 // FIXME -- just link toward the end, before any qh with a shorter period,
 420 // AND accommodate it already having been linked here (after some other qh)
 421 // AS WELL AS updating the schedule checking logic
 422
 423                         BUG ();
 424                 } else {
 425                         ehci->pshadow [frame].qh = qh_get (qh);
 426                         ehci->periodic [frame] =
 427                                 QH_NEXT (qh->qh_dma);
 428                 }
 429                 wmb ();
 430                 frame += qh->period;
 431         } while (frame < ehci->periodic_size);
 432
 433         /* update per-qh bandwidth for usbfs */
 434         hcd_to_bus (&ehci->hcd)->bandwidth_allocated +=
 435                 (qh->usecs + qh->c_usecs) / qh->period;
 436
 437         /* maybe enable periodic schedule processing */
 438         if (!ehci->periodic_sched++)
 439                 status = enable_periodic (ehci);
 440 done:
 441         return status;
 442 }
 443
 444 static int intr_submit (
 445         struct ehci_hcd         *ehci,
 446         struct urb              *urb,
 447         struct list_head        *qtd_list,
 448         int                     mem_flags
 449 ) {
 450         unsigned                epnum;
 451         unsigned long           flags;
 452         struct ehci_qh          *qh;
 453         struct hcd_dev          *dev;
 454         int                     is_input;
 455         int                     status = 0;
 456         struct list_head        empty;
 457
 458         /* get endpoint and transfer/schedule data */
 459         epnum = usb_pipeendpoint (urb->pipe);
 460         is_input = usb_pipein (urb->pipe);
 461         if (is_input)
 462                 epnum |= 0x10;
 463
 464         spin_lock_irqsave (&ehci->lock, flags);
 465         dev = (struct hcd_dev *)urb->dev->hcpriv;
 466
 467         /* get qh and force any scheduling errors */
 468         INIT_LIST_HEAD (&empty);
 469         qh = qh_append_tds (ehci, urb, &empty, epnum, &dev->ep [epnum]);
 470         if (qh == 0) {
 471                 status = -ENOMEM;
 472                 goto done;
 473         }
 474         if (qh->qh_state == QH_STATE_IDLE) {
 475                 if ((status = qh_schedule (ehci, qh)) != 0)
 476                         goto done;
 477         }
 478
 479         /* then queue the urb's tds to the qh */
 480         qh = qh_append_tds (ehci, urb, qtd_list, epnum, &dev->ep [epnum]);
 481         BUG_ON (qh == 0);
 482
 483         /* ... update usbfs periodic stats */
 484         hcd_to_bus (&ehci->hcd)->bandwidth_int_reqs++;
 485
 486 done:
 487         spin_unlock_irqrestore (&ehci->lock, flags);
 488         if (status)
 489                 qtd_list_free (ehci, urb, qtd_list);
 490
 491         return status;
 492 }
 493
 494 static unsigned
 495 intr_complete (
 496         struct ehci_hcd *ehci,
 497         unsigned        frame,
 498         struct ehci_qh  *qh,
 499         struct pt_regs  *regs
 500 ) {
 501         unsigned        count;
 502
 503         /* nothing to report? */
 504         if (likely ((qh->hw_token & __constant_cpu_to_le32 (QTD_STS_ACTIVE))
 505                         != 0))
 506                 return 0;
 507         if (unlikely (list_empty (&qh->qtd_list))) {
 508                 dbg ("intr qh %p no TDs?", qh);
 509                 return 0;
 510         }
 511
 512         /* handle any completions */
 513         count = qh_completions (ehci, qh, regs);
 514
 515         if (unlikely (list_empty (&qh->qtd_list)))
 516                 intr_deschedule (ehci, qh, 0);
 517
 518         return count;
 519 }
 520
 521 /*-------------------------------------------------------------------------*/
 522
 523 static void
 524 itd_free_list (struct ehci_hcd *ehci, struct urb *urb)
 525 {
 526         struct ehci_itd *first_itd = urb->hcpriv;
 527
 528         while (!list_empty (&first_itd->itd_list)) {
 529                 struct ehci_itd *itd;
 530
 531                 itd = list_entry (
 532                         first_itd->itd_list.next,
 533                         struct ehci_itd, itd_list);
 534                 list_del (&itd->itd_list);
 535                 pci_pool_free (ehci->itd_pool, itd, itd->itd_dma);
 536         }
 537         pci_pool_free (ehci->itd_pool, first_itd, first_itd->itd_dma);
 538         urb->hcpriv = 0;
 539 }
 540
 541 static int
 542 itd_fill (
 543         struct ehci_hcd *ehci,
 544         struct ehci_itd *itd,
 545         struct urb      *urb,
 546         unsigned        index,          // urb->iso_frame_desc [index]
 547         dma_addr_t      dma             // mapped transfer buffer
 548 ) {
 549         u64             temp;
 550         u32             buf1;
 551         unsigned        i, epnum, maxp, multi;
 552         unsigned        length;
 553         int             is_input;
 554
 555         itd->hw_next = EHCI_LIST_END;
 556         itd->urb = urb;
 557         itd->index = index;
 558
 559         /* tell itd about its transfer buffer, max 2 pages */
 560         length = urb->iso_frame_desc [index].length;
 561         dma += urb->iso_frame_desc [index].offset;
 562         temp = dma & ~0x0fff;
 563         for (i = 0; i < 2; i++) {
 564                 itd->hw_bufp [i] = cpu_to_le32 ((u32) temp);
 565                 itd->hw_bufp_hi [i] = cpu_to_le32 ((u32)(temp >> 32));
 566                 temp += 0x1000;
 567         }
 568         itd->buf_dma = dma;
 569
 570         /*
 571          * this might be a "high bandwidth" highspeed endpoint,
 572          * as encoded in the ep descriptor's maxpacket field
 573          */
 574         epnum = usb_pipeendpoint (urb->pipe);
 575         is_input = usb_pipein (urb->pipe);
 576         if (is_input) {
 577                 maxp = urb->dev->epmaxpacketin [epnum];
 578                 buf1 = (1 << 11);
 579         } else {
 580                 maxp = urb->dev->epmaxpacketout [epnum];
 581                 buf1 = 0;
 582         }
 583         buf1 |= (maxp & 0x03ff);
 584         multi = 1;
 585         multi += (maxp >> 11) & 0x03;
 586         maxp &= 0x03ff;
 587         maxp *= multi;
 588
 589         /* transfer can't fit in any uframe? */
 590         if (length < 0 || maxp < length) {
 591                 dbg ("BAD iso packet: %d bytes, max %d, urb %p [%d] (of %d)",
 592                         length, maxp, urb, index,
 593                         urb->iso_frame_desc [index].length);
 594                 return -ENOSPC;
 595         }
 596         itd->usecs = usb_calc_bus_time (USB_SPEED_HIGH, is_input, 1, length);
 597
 598         /* "plus" info in low order bits of buffer pointers */
 599         itd->hw_bufp [0] |= cpu_to_le32 ((epnum << 8) | urb->dev->devnum);
 600         itd->hw_bufp [1] |= cpu_to_le32 (buf1);
 601         itd->hw_bufp [2] |= cpu_to_le32 (multi);
 602
 603         /* figure hw_transaction[] value (it's scheduled later) */
 604         itd->transaction = EHCI_ISOC_ACTIVE;
 605         itd->transaction |= dma & 0x0fff;               /* offset; buffer=0 */
 606         if ((index + 1) == urb->number_of_packets)
 607                 itd->transaction |= EHCI_ITD_IOC;       /* end-of-urb irq */
 608         itd->transaction |= length << 16;
 609         cpu_to_le32s (&itd->transaction);
 610
 611         return 0;
 612 }
 613
 614 static int
 615 itd_urb_transaction (
 616         struct ehci_hcd         *ehci,
 617         struct urb              *urb,
 618         int                     mem_flags
 619 ) {
 620         int                     frame_index;
 621         struct ehci_itd         *first_itd, *itd;
 622         int                     status;
 623         dma_addr_t              itd_dma;
 624
 625         /* allocate/init ITDs */
 626         for (frame_index = 0, first_itd = 0;
 627                         frame_index < urb->number_of_packets;
 628                         frame_index++) {
 629                 itd = pci_pool_alloc (ehci->itd_pool, mem_flags, &itd_dma);
 630                 if (!itd) {
 631                         status = -ENOMEM;
 632                         goto fail;
 633                 }
 634                 memset (itd, 0, sizeof *itd);
 635                 itd->itd_dma = itd_dma;
 636
 637                 status = itd_fill (ehci, itd, urb, frame_index,
 638                                 urb->transfer_dma);
 639                 if (status != 0)
 640                         goto fail;
 641
 642                 if (first_itd)
 643                         list_add_tail (&itd->itd_list,
 644                                         &first_itd->itd_list);
 645                 else {
 646                         INIT_LIST_HEAD (&itd->itd_list);
 647                         urb->hcpriv = first_itd = itd;
 648                 }
 649         }
 650         urb->error_count = 0;
 651         return 0;
 652
 653 fail:
 654         if (urb->hcpriv)
 655                 itd_free_list (ehci, urb);
 656         return status;
 657 }
 658
 659 /*-------------------------------------------------------------------------*/
 660
 661 static inline void
 662 itd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_itd *itd)
 663 {
 664         /* always prepend ITD/SITD ... only QH tree is order-sensitive */
 665         itd->itd_next = ehci->pshadow [frame];
 666         itd->hw_next = ehci->periodic [frame];
 667         ehci->pshadow [frame].itd = itd;
 668         ehci->periodic [frame] = cpu_to_le32 (itd->itd_dma) | Q_TYPE_ITD;
 669 }
 670
 671 /*
 672  * return zero on success, else -errno
 673  * - start holds first uframe to start scheduling into
 674  * - max is the first uframe it's NOT (!) OK to start scheduling into
 675  * math to be done modulo "mod" (ehci->periodic_size << 3)
 676  */
 677 static int get_iso_range (
 678         struct ehci_hcd         *ehci,
 679         struct urb              *urb,
 680         unsigned                *start,
 681         unsigned                *max,
 682         unsigned                mod
 683 ) {
 684         struct list_head        *lh;
 685         struct hcd_dev          *dev = urb->dev->hcpriv;
 686         int                     last = -1;
 687         unsigned                now, span, end;
 688
 689         span = urb->interval * urb->number_of_packets;
 690
 691         /* first see if we know when the next transfer SHOULD happen */
 692         list_for_each (lh, &dev->urb_list) {
 693                 struct urb      *u;
 694                 struct ehci_itd *itd;
 695                 unsigned        s;
 696
 697                 u = list_entry (lh, struct urb, urb_list);
 698                 if (u == urb || u->pipe != urb->pipe)
 699                         continue;
 700                 if (u->interval != urb->interval) {     /* must not change! */
 701                         dbg ("urb %p interval %d ... != %p interval %d",
 702                                 u, u->interval, urb, urb->interval);
 703                         return -EINVAL;
 704                 }
 705
 706                 /* URB for this endpoint... covers through when?  */
 707                 itd = urb->hcpriv;
 708                 s = itd->uframe + u->interval * u->number_of_packets;
 709                 if (last < 0)
 710                         last = s;
 711                 else {
 712                         /*
 713                          * So far we can only queue two ISO URBs...
 714                          *
 715                          * FIXME do interval math, figure out whether
 716                          * this URB is "before" or not ... also, handle
 717                          * the case where the URB might have completed,
 718                          * but hasn't yet been processed.
 719                          */
 720                         dbg ("NYET: queue >2 URBs per ISO endpoint");
 721                         return -EDOM;
 722                 }
 723         }
 724
 725         /* calculate the legal range [start,max) */
 726         now = readl (&ehci->regs->frame_index) + 1;     /* next uframe */
 727         if (!ehci->periodic_sched)
 728                 now += 8;                               /* startup delay */
 729         now %= mod;
 730         end = now + mod;
 731         if (last < 0) {
 732                 *start = now + ehci->i_thresh + /* paranoia */ 1;
 733                 *max = end - span;
 734                 if (*max < *start + 1)
 735                         *max = *start + 1;
 736         } else {
 737                 *start = last % mod;
 738                 *max = (last + 1) % mod;
 739         }
 740
 741         /* explicit start frame? */
 742         if (!(urb->transfer_flags & URB_ISO_ASAP)) {
 743                 unsigned        temp;
 744
 745                 /* sanity check: must be in range */
 746                 urb->start_frame %= ehci->periodic_size;
 747                 temp = urb->start_frame << 3;
 748                 if (temp < *start)
 749                         temp += mod;
 750                 if (temp > *max)
 751                         return -EDOM;
 752
 753                 /* use that explicit start frame */
 754                 *start = urb->start_frame << 3;
 755                 temp += 8;
 756                 if (temp < *max)
 757                         *max = temp;
 758         }
 759
 760         // FIXME minimize wraparound to "now" ... insist max+span
 761         // (and start+span) remains a few frames short of "end"
 762
 763         *max %= ehci->periodic_size;
 764         if ((*start + span) < end)
 765                 return 0;
 766         return -EFBIG;
 767 }
 768
 769 static int
 770 itd_schedule (struct ehci_hcd *ehci, struct urb *urb)
 771 {
 772         unsigned        start, max, i;
 773         int             status;
 774         unsigned        mod = ehci->periodic_size << 3;
 775
 776         for (i = 0; i < urb->number_of_packets; i++) {
 777                 urb->iso_frame_desc [i].status = -EINPROGRESS;
 778                 urb->iso_frame_desc [i].actual_length = 0;
 779         }
 780
 781         if ((status = get_iso_range (ehci, urb, &start, &max, mod)) != 0)
 782                 return status;
 783
 784         do {
 785                 unsigned        uframe;
 786                 unsigned        usecs;
 787                 struct ehci_itd *itd;
 788
 789                 /* check schedule: enough space? */
 790                 itd = urb->hcpriv;
 791                 uframe = start;
 792                 for (i = 0, uframe = start;
 793                                 i < urb->number_of_packets;
 794                                 i++, uframe += urb->interval) {
 795                         uframe %= mod;
 796
 797                         /* can't commit more than 80% periodic == 100 usec */
 798                         if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)
 799                                         > (100 - itd->usecs)) {
 800                                 itd = 0;
 801                                 break;
 802                         }
 803                         itd = list_entry (itd->itd_list.next,
 804                                 struct ehci_itd, itd_list);
 805                 }
 806                 if (!itd)
 807                         continue;
 808
 809                 /* that's where we'll schedule this! */
 810                 itd = urb->hcpriv;
 811                 urb->start_frame = start >> 3;
 812                 vdbg ("ISO urb %p (%d packets period %d) starting %d.%d",
 813                         urb, urb->number_of_packets, urb->interval,
 814                         urb->start_frame, start & 0x7);
 815                 for (i = 0, uframe = start, usecs = 0;
 816                                 i < urb->number_of_packets;
 817                                 i++, uframe += urb->interval) {
 818                         uframe %= mod;
 819
 820                         itd->uframe = uframe;
 821                         itd->hw_transaction [uframe & 0x07] = itd->transaction;
 822                         itd_link (ehci, (uframe >> 3) % ehci->periodic_size,
 823                                 itd);
 824                         wmb ();
 825                         usecs += itd->usecs;
 826
 827                         itd = list_entry (itd->itd_list.next,
 828                                 struct ehci_itd, itd_list);
 829                 }
 830
 831                 /* update bandwidth utilization records (for usbfs)
 832                  *
 833                  * FIXME This claims each URB queued to an endpoint, as if
 834                  * transfers were concurrent, not sequential.  So bandwidth
 835                  * typically gets double-billed ... comes from tying it to
 836                  * URBs rather than endpoints in the schedule.  Luckily we
 837                  * don't use this usbfs data for serious decision making.
 838                  */
 839                 usecs /= urb->number_of_packets;
 840                 usecs /= urb->interval;
 841                 usecs >>= 3;
 842                 if (usecs < 1)
 843                         usecs = 1;
 844                 usb_claim_bandwidth (urb->dev, urb, usecs, 1);
 845
 846                 /* maybe enable periodic schedule processing */
 847                 if (!ehci->periodic_sched++) {
 848                         if ((status =  enable_periodic (ehci)) != 0) {
 849                                 // FIXME deschedule right away
 850                                 err ("itd_schedule, enable = %d", status);
 851                         }
 852                 }
 853
 854                 return 0;
 855
 856         } while ((start = ++start % mod) != max);
 857
 858         /* no room in the schedule */
 859         dbg ("urb %p, CAN'T SCHEDULE", urb);
 860         return -ENOSPC;
 861 }
 862
 863 /*-------------------------------------------------------------------------*/
 864
 865 #define ISO_ERRS (EHCI_ISOC_BUF_ERR | EHCI_ISOC_BABBLE | EHCI_ISOC_XACTERR)
 866
 867 static unsigned
 868 itd_complete (
 869         struct ehci_hcd *ehci,
 870         struct ehci_itd *itd,
 871         unsigned        uframe,
 872         struct pt_regs  *regs
 873 ) {
 874         struct urb                              *urb = itd->urb;
 875         struct usb_iso_packet_descriptor        *desc;
 876         u32                                     t;
 877
 878         /* update status for this uframe's transfers */
 879         desc = &urb->iso_frame_desc [itd->index];
 880
 881         t = itd->hw_transaction [uframe];
 882         itd->hw_transaction [uframe] = 0;
 883         if (t & EHCI_ISOC_ACTIVE)
 884                 desc->status = -EXDEV;
 885         else if (t & ISO_ERRS) {
 886                 urb->error_count++;
 887                 if (t & EHCI_ISOC_BUF_ERR)
 888                         desc->status = usb_pipein (urb->pipe)
 889                                 ? -ENOSR  /* couldn't read */
 890                                 : -ECOMM; /* couldn't write */
 891                 else if (t & EHCI_ISOC_BABBLE)
 892                         desc->status = -EOVERFLOW;
 893                 else /* (t & EHCI_ISOC_XACTERR) */
 894                         desc->status = -EPROTO;
 895
 896                 /* HC need not update length with this error */
 897                 if (!(t & EHCI_ISOC_BABBLE))
 898                         desc->actual_length += EHCI_ITD_LENGTH (t);
 899         } else {
 900                 desc->status = 0;
 901                 desc->actual_length += EHCI_ITD_LENGTH (t);
 902         }
 903
 904         vdbg ("itd %p urb %p packet %d/%d trans %x status %d len %d",
 905                 itd, urb, itd->index + 1, urb->number_of_packets,
 906                 t, desc->status, desc->actual_length);
 907
 908         /* handle completion now? */
 909         if ((itd->index + 1) != urb->number_of_packets)
 910                 return 0;
 911
 912         /*
 913          * Always give the urb back to the driver ... expect it to submit
 914          * a new urb (or resubmit this), and to have another already queued
 915          * when un-interrupted transfers are needed.
 916          *
 917          * NOTE that for now we don't accelerate ISO unlinks; they just
 918          * happen according to the current schedule.  Means a delay of
 919          * up to about a second (max).
 920          */
 921         itd_free_list (ehci, urb);
 922         if (urb->status == -EINPROGRESS)
 923                 urb->status = 0;
 924
 925         /* complete() can reenter this HCD */
 926         spin_unlock (&ehci->lock);
 927         usb_hcd_giveback_urb (&ehci->hcd, urb, regs);
 928         spin_lock (&ehci->lock);
 929
 930         /* defer stopping schedule; completion can submit */
 931         ehci->periodic_sched--;
 932         if (!ehci->periodic_sched)
 933                 (void) disable_periodic (ehci);
 934
 935         return 1;
 936 }
 937
 938 /*-------------------------------------------------------------------------*/
 939
 940 static int itd_submit (struct ehci_hcd *ehci, struct urb *urb, int mem_flags)
 941 {
 942         int             status;
 943         unsigned long   flags;
 944
 945         dbg ("itd_submit urb %p", urb);
 946
 947         /* allocate ITDs w/o locking anything */
 948         status = itd_urb_transaction (ehci, urb, mem_flags);
 949         if (status < 0)
 950                 return status;
 951
 952         /* schedule ... need to lock */
 953         spin_lock_irqsave (&ehci->lock, flags);
 954         status = itd_schedule (ehci, urb);
 955         spin_unlock_irqrestore (&ehci->lock, flags);
 956         if (status < 0)
 957                 itd_free_list (ehci, urb);
 958
 959         return status;
 960 }
 961
 962 #ifdef have_split_iso
 963
 964 /*-------------------------------------------------------------------------*/
 965
 966 /*
 967  * "Split ISO TDs" ... used for USB 1.1 devices going through
 968  * the TTs in USB 2.0 hubs.
 969  *
 970  * FIXME not yet implemented
 971  */
 972
 973 #endif /* have_split_iso */
 974
 975 /*-------------------------------------------------------------------------*/
 976
 977 static void
 978 scan_periodic (struct ehci_hcd *ehci, struct pt_regs *regs)
 979 {
 980         unsigned        frame, clock, now_uframe, mod;
 981         unsigned        count = 0;
 982
 983         mod = ehci->periodic_size << 3;
 984
 985         /*
 986          * When running, scan from last scan point up to "now"
 987          * else clean up by scanning everything that's left.
 988          * Touches as few pages as possible:  cache-friendly.
 989          * Don't scan ISO entries more than once, though.
 990          */
 991         frame = ehci->next_uframe >> 3;
 992         if (HCD_IS_RUNNING (ehci->hcd.state))
 993                 now_uframe = readl (&ehci->regs->frame_index);
 994         else
 995                 now_uframe = (frame << 3) - 1;
 996         now_uframe %= mod;
 997         clock = now_uframe >> 3;
 998
 999         for (;;) {
1000                 union ehci_shadow       q, *q_p;
1001                 u32                     type, *hw_p;
1002                 unsigned                uframes;
1003
1004 restart:
1005                 /* scan schedule to _before_ current frame index */
1006                 if (frame == clock)
1007                         uframes = now_uframe & 0x07;
1008                 else
1009                         uframes = 8;
1010
1011                 q_p = &ehci->pshadow [frame];
1012                 hw_p = &ehci->periodic [frame];
1013                 q.ptr = q_p->ptr;
1014                 type = Q_NEXT_TYPE (*hw_p);
1015
1016                 /* scan each element in frame's queue for completions */
1017                 while (q.ptr != 0) {
1018                         int                     last;
1019                         unsigned                uf;
1020                         union ehci_shadow       temp;
1021
1022                         switch (type) {
1023                         case Q_TYPE_QH:
1024                                 last = (q.qh->hw_next == EHCI_LIST_END);
1025                                 temp = q.qh->qh_next;
1026                                 type = Q_NEXT_TYPE (q.qh->hw_next);
1027                                 count += intr_complete (ehci, frame,
1028                                                 qh_get (q.qh), regs);
1029                                 qh_put (ehci, q.qh);
1030                                 q = temp;
1031                                 break;
1032                         case Q_TYPE_FSTN:
1033                                 last = (q.fstn->hw_next == EHCI_LIST_END);
1034                                 /* for "save place" FSTNs, look at QH entries
1035                                  * in the previous frame for completions.
1036                                  */
1037                                 if (q.fstn->hw_prev != EHCI_LIST_END) {
1038                                         dbg ("ignoring completions from FSTNs");
1039                                 }
1040                                 type = Q_NEXT_TYPE (q.fstn->hw_next);
1041                                 q = q.fstn->fstn_next;
1042                                 break;
1043                         case Q_TYPE_ITD:
1044                                 last = (q.itd->hw_next == EHCI_LIST_END);
1045
1046                                 /* Unlink each (S)ITD we see, since the ISO
1047                                  * URB model forces constant rescheduling.
1048                                  * That complicates sharing uframes in ITDs,
1049                                  * and means we need to skip uframes the HC
1050                                  * hasn't yet processed.
1051                                  */
1052                                 for (uf = 0; uf < uframes; uf++) {
1053                                         if (q.itd->hw_transaction [uf] != 0) {
1054                                                 temp = q;
1055                                                 *q_p = q.itd->itd_next;
1056                                                 *hw_p = q.itd->hw_next;
1057                                                 type = Q_NEXT_TYPE (*hw_p);
1058
1059                                                 /* might free q.itd ... */
1060                                                 count += itd_complete (ehci,
1061                                                         temp.itd, uf, regs);
1062                                                 break;
1063                                         }
1064                                 }
1065                                 /* we might skip this ITD's uframe ... */
1066                                 if (uf == uframes) {
1067                                         q_p = &q.itd->itd_next;
1068                                         hw_p = &q.itd->hw_next;
1069                                         type = Q_NEXT_TYPE (q.itd->hw_next);
1070                                 }
1071
1072                                 q = *q_p;
1073                                 break;
1074 #ifdef have_split_iso
1075                         case Q_TYPE_SITD:
1076                                 last = (q.sitd->hw_next == EHCI_LIST_END);
1077                                 sitd_complete (ehci, q.sitd);
1078                                 type = Q_NEXT_TYPE (q.sitd->hw_next);
1079
1080                                 // FIXME unlink SITD after split completes
1081                                 q = q.sitd->sitd_next;
1082                                 break;
1083 #endif /* have_split_iso */
1084                         default:
1085                                 dbg ("corrupt type %d frame %d shadow %p",
1086                                         type, frame, q.ptr);
1087                                 // BUG ();
1088                                 last = 1;
1089                                 q.ptr = 0;
1090                         }
1091
1092                         /* did completion remove an interior q entry? */
1093                         if (unlikely (q.ptr == 0 && !last))
1094                                 goto restart;
1095                 }
1096
1097                 /* stop when we catch up to the HC */
1098
1099                 // FIXME:  this assumes we won't get lapped when
1100                 // latencies climb; that should be rare, but...
1101                 // detect it, and just go all the way around.
1102                 // FLR might help detect this case, so long as latencies
1103                 // don't exceed periodic_size msec (default 1.024 sec).
1104
1105                 // FIXME:  likewise assumes HC doesn't halt mid-scan
1106
1107                 if (frame == clock) {
1108                         unsigned        now;
1109
1110                         if (!HCD_IS_RUNNING (ehci->hcd.state))
1111                                 break;
1112                         ehci->next_uframe = now_uframe;
1113                         now = readl (&ehci->regs->frame_index) % mod;
1114                         if (now_uframe == now)
1115                                 break;
1116
1117                         /* rescan the rest of this frame, then ... */
1118                         now_uframe = now;
1119                         clock = now_uframe >> 3;
1120                 } else
1121                         frame = (frame + 1) % ehci->periodic_size;
1122         }
1123 }