开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ehci-sched.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：32k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.  */
  19. /* this file is part of ehci-hcd.c */
  21. /*-------------------------------------------------------------------------*/
  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.  */
  36. /*
  37.  * Ceiling microseconds (typical) for that many bytes at high speed
  38.  * ISO is a bit less, no ACK ... from USB 2.0 spec, 5.11.3 (and needed
  39.  * to preallocate bandwidth)
  40.  */
  41. #define EHCI_HOST_DELAY 5 /* nsec, guess */
  42. #define HS_USECS(bytes) NS_TO_US ( ((55 * 8 * 2083)/1000) 
  43. + ((2083UL * (3167 + BitTime (bytes)))/1000) 
  44. + EHCI_HOST_DELAY)
  45. #define HS_USECS_ISO(bytes) NS_TO_US ( ((long)(38 * 8 * 2.083)) 
  46. + ((2083UL * (3167 + BitTime (bytes)))/1000) 
  47. + EHCI_HOST_DELAY)
  49. static int ehci_get_frame (struct usb_hcd *hcd);
  51. /*-------------------------------------------------------------------------*/
  53. /*
  54.  * periodic_next_shadow - return "next" pointer on shadow list
  55.  * @periodic: host pointer to qh/itd/sitd
  56.  * @tag: hardware tag for type of this record
  57.  */
  58. static union ehci_shadow *
  59. periodic_next_shadow (union ehci_shadow *periodic, int tag)
  60. {
  61. switch (tag) {
  62. case Q_TYPE_QH:
  63. return &periodic->qh->qh_next;
  64. case Q_TYPE_FSTN:
  65. return &periodic->fstn->fstn_next;
  66. case Q_TYPE_ITD:
  67. return &periodic->itd->itd_next;
  68. #ifdef have_split_iso
  69. case Q_TYPE_SITD:
  70. return &periodic->sitd->sitd_next;
  71. #endif /* have_split_iso */
  72. }
  73. dbg ("BAD shadow %p tag %d", periodic->ptr, tag);
  74. // BUG ();
  75. return 0;
  76. }
  78. /* returns true after successful unlink */
  79. /* caller must hold ehci->lock */
  80. static int periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
  81. {
  82. union ehci_shadow *prev_p = &ehci->pshadow [frame];
  83. u32 *hw_p = &ehci->periodic [frame];
  84. union ehci_shadow here = *prev_p;
  85. union ehci_shadow *next_p;
  87. /* find predecessor of "ptr"; hw and shadow lists are in sync */
  88. while (here.ptr && here.ptr != ptr) {
  89. prev_p = periodic_next_shadow (prev_p, Q_NEXT_TYPE (*hw_p));
  90. hw_p = &here.qh->hw_next;
  91. here = *prev_p;
  92. }
  93. /* an interrupt entry (at list end) could have been shared */
  94. if (!here.ptr) {
  95. dbg ("entry %p no longer on frame [%d]", ptr, frame);
  96. return 0;
  97. }
  98. // vdbg ("periodic unlink %p from frame %d", ptr, frame);
  100. /* update hardware list ... HC may still know the old structure, so
  101.  * don't change hw_next until it'll have purged its cache
  102.  */
  103. next_p = periodic_next_shadow (&here, Q_NEXT_TYPE (*hw_p));
  104. *hw_p = here.qh->hw_next;
  106. /* unlink from shadow list; HCD won't see old structure again */
  107. *prev_p = *next_p;
  108. next_p->ptr = 0;
  110. return 1;
  111. }
  113. /* how many of the uframe's 125 usecs are allocated? */
  114. static unsigned short
  115. periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
  116. {
  117. u32 *hw_p = &ehci->periodic [frame];
  118. union ehci_shadow *q = &ehci->pshadow [frame];
  119. unsigned usecs = 0;
  121. while (q->ptr) {
  122. switch (Q_NEXT_TYPE (*hw_p)) {
  123. case Q_TYPE_QH:
  124. /* is it in the S-mask? */
  125. if (q->qh->hw_info2 & cpu_to_le32 (1 << uframe))
  126. usecs += q->qh->usecs;
  127. q = &q->qh->qh_next;
  128. break;
  129. case Q_TYPE_FSTN:
  130. /* for "save place" FSTNs, count the relevant INTR
  131.  * bandwidth from the previous frame
  132.  */
  133. if (q->fstn->hw_prev != EHCI_LIST_END) {
  134. dbg ("not counting FSTN bandwidth yet ...");
  135. }
  136. q = &q->fstn->fstn_next;
  137. break;
  138. case Q_TYPE_ITD:
  139. /* NOTE the "one uframe per itd" policy */
  140. if (q->itd->hw_transaction [uframe] != 0)
  141. usecs += q->itd->usecs;
  142. q = &q->itd->itd_next;
  143. break;
  144. #ifdef have_split_iso
  145. case Q_TYPE_SITD:
  146. temp = q->sitd->hw_fullspeed_ep &
  147. __constant_cpu_to_le32 (1 << 31);
  149. // FIXME:  this doesn't count data bytes right...
  151. /* is it in the S-mask?  (count SPLIT, DATA) */
  152. if (q->sitd->hw_uframe & cpu_to_le32 (1 << uframe)) {
  153. if (temp)
  154. usecs += HS_USECS (188);
  155. else
  156. usecs += HS_USECS (1);
  157. }
  159. /* ... C-mask?  (count CSPLIT, DATA) */
  160. if (q->sitd->hw_uframe &
  161. cpu_to_le32 (1 << (8 + uframe))) {
  162. if (temp)
  163. usecs += HS_USECS (0);
  164. else
  165. usecs += HS_USECS (188);
  166. }
  167. q = &q->sitd->sitd_next;
  168. break;
  169. #endif /* have_split_iso */
  170. default:
  171. BUG ();
  172. }
  173. }
  174. #ifdef DEBUG
  175. if (usecs > 100)
  176. err ("overallocated uframe %d, periodic is %d usecs",
  177. frame * 8 + uframe, usecs);
  178. #endif
  179. return usecs;
  180. }
  182. /*-------------------------------------------------------------------------*/
  184. static void enable_periodic (struct ehci_hcd *ehci)
  185. {
  186. u32 cmd;
  188. /* did clearing PSE did take effect yet?
  189.  * takes effect only at frame boundaries...
  190.  */
  191. while (readl (&ehci->regs->status) & STS_PSS)
  192. udelay (20);
  194. cmd = readl (&ehci->regs->command) | CMD_PSE;
  195. writel (cmd, &ehci->regs->command);
  196. /* posted write ... PSS happens later */
  197. ehci->hcd.state = USB_STATE_RUNNING;
  199. /* make sure tasklet scans these */
  200. ehci->next_uframe = readl (&ehci->regs->frame_index)
  201. % (ehci->periodic_size << 3);
  202. }
  204. static void disable_periodic (struct ehci_hcd *ehci)
  205. {
  206. u32 cmd;
  208. /* did setting PSE not take effect yet?
  209.  * takes effect only at frame boundaries...
  210.  */
  211. while (!(readl (&ehci->regs->status) & STS_PSS))
  212. udelay (20);
  214. cmd = readl (&ehci->regs->command) & ~CMD_PSE;
  215. writel (cmd, &ehci->regs->command);
  216. /* posted write ... */
  218. ehci->next_uframe = -1;
  219. }
  221. /*-------------------------------------------------------------------------*/
  223. static void intr_deschedule (
  224. struct ehci_hcd *ehci,
  225. unsigned frame,
  226. struct ehci_qh *qh,
  227. unsigned period
  228. ) {
  229. unsigned long flags;
  231. period >>= 3; // FIXME microframe periods not handled yet
  233. spin_lock_irqsave (&ehci->lock, flags);
  235. do {
  236. periodic_unlink (ehci, frame, qh);
  237. qh_put (ehci, qh);
  238. frame += period;
  239. } while (frame < ehci->periodic_size);
  241. qh->qh_state = QH_STATE_UNLINK;
  242. qh->qh_next.ptr = 0;
  243. ehci->periodic_urbs--;
  245. /* maybe turn off periodic schedule */
  246. if (!ehci->periodic_urbs)
  247. disable_periodic (ehci);
  248. else
  249. vdbg ("periodic schedule still enabled");
  251. spin_unlock_irqrestore (&ehci->lock, flags);
  253. /*
  254.  * If the hc may be looking at this qh, then delay a uframe
  255.  * (yeech!) to be sure it's done.
  256.  * No other threads may be mucking with this qh.
  257.  */
  258. if (((ehci_get_frame (&ehci->hcd) - frame) % period) == 0)
  259. udelay (125);
  261. qh->qh_state = QH_STATE_IDLE;
  262. qh->hw_next = EHCI_LIST_END;
  264. vdbg ("descheduled qh %p, per = %d frame = %d count = %d, urbs = %d",
  265. qh, period, frame,
  266. atomic_read (&qh->refcount), ehci->periodic_urbs);
  267. }
  269. static int check_period (
  270. struct ehci_hcd *ehci, 
  271. unsigned frame,
  272. int uframe,
  273. unsigned period,
  274. unsigned usecs
  275. ) {
  276. /*
  277.  * 80% periodic == 100 usec/uframe available
  278.  * convert "usecs we need" to "max already claimed" 
  279.  */
  280. usecs = 100 - usecs;
  282. do {
  283. int claimed;
  285. // FIXME delete when intr_submit handles non-empty queues
  286. // this gives us a one intr/frame limit (vs N/uframe)
  287. if (ehci->pshadow [frame].ptr)
  288. return 0;
  290. claimed = periodic_usecs (ehci, frame, uframe);
  291. if (claimed > usecs)
  292. return 0;
  294. // FIXME update to handle sub-frame periods
  295. } while ((frame += period) < ehci->periodic_size);
  297. // success!
  298. return 1;
  299. }
  301. static int intr_submit (
  302. struct ehci_hcd *ehci,
  303. struct urb *urb,
  304. struct list_head *qtd_list,
  305. int mem_flags
  306. ) {
  307. unsigned epnum, period;
  308. unsigned short usecs;
  309. unsigned long flags;
  310. struct ehci_qh *qh;
  311. struct hcd_dev *dev;
  312. int status = 0;
  314. /* get endpoint and transfer data */
  315. epnum = usb_pipeendpoint (urb->pipe);
  316. if (usb_pipein (urb->pipe))
  317. epnum |= 0x10;
  318. if (urb->dev->speed != USB_SPEED_HIGH) {
  319. dbg ("no intr/tt scheduling yet"); 
  320. status = -ENOSYS;
  321. goto done;
  322. }
  324. /*
  325.  * NOTE: current completion/restart logic doesn't handle more than
  326.  * one qtd in a periodic qh ... 16-20 KB/urb is pretty big for this.
  327.  * such big requests need many periods to transfer.
  328.  *
  329.  * FIXME want to change hcd core submit model to expect queuing
  330.  * for all transfer types ... not just ISO and (with flag) BULK.
  331.  * that means: getting rid of this check; handling the "interrupt
  332.  * urb already queued" case below like bulk queuing is handled (no
  333.  * errors possible!); and completly getting rid of that annoying
  334.  * qh restart logic.  simpler/smaller overall, and more flexible.
  335.  */
  336. if (unlikely (qtd_list->next != qtd_list->prev)) {
  337. dbg ("only one intr qtd per urb allowed"); 
  338. status = -EINVAL;
  339. goto done;
  340. }
  342. usecs = HS_USECS (urb->transfer_buffer_length);
  344. /* FIXME handle HS periods of less than 1 frame. */
  345. period = urb->interval >> 3;
  346. if (period < 1) {
  347. dbg ("intr period %d uframes, NYET!", urb->interval);
  348. status = -EINVAL;
  349. goto done;
  350. }
  352. spin_lock_irqsave (&ehci->lock, flags);
  354. /* get the qh (must be empty and idle) */
  355. dev = (struct hcd_dev *)urb->dev->hcpriv;
  356. qh = (struct ehci_qh *) dev->ep [epnum];
  357. if (qh) {
  358. /* only allow one queued interrupt urb per EP */
  359. if (unlikely (qh->qh_state != QH_STATE_IDLE
  360. || !list_empty (&qh->qtd_list))) {
  361. dbg ("interrupt urb already queued");
  362. status = -EBUSY;
  363. } else {
  364. /* maybe reset hardware's data toggle in the qh */
  365. if (unlikely (!usb_gettoggle (urb->dev, epnum & 0x0f,
  366. !(epnum & 0x10)))) {
  367. qh->hw_token |=
  368. __constant_cpu_to_le32 (QTD_TOGGLE);
  369. usb_settoggle (urb->dev, epnum & 0x0f,
  370. !(epnum & 0x10), 1);
  371. }
  372. /* trust the QH was set up as interrupt ... */
  373. list_splice (qtd_list, &qh->qtd_list);
  374. qh_update (qh, list_entry (qtd_list->next,
  375. struct ehci_qtd, qtd_list));
  376. qtd_list = &qh->qtd_list;
  377. }
  378. } else {
  379. /* can't sleep here, we have ehci->lock... */
  380. qh = ehci_qh_make (ehci, urb, qtd_list, SLAB_ATOMIC);
  381. if (likely (qh != 0)) {
  382. // dbg ("new INTR qh %p", qh);
  383. dev->ep [epnum] = qh;
  384. qtd_list = &qh->qtd_list;
  385. } else
  386. status = -ENOMEM;
  387. }
  389. /* Schedule this periodic QH. */
  390. if (likely (status == 0)) {
  391. unsigned frame = period;
  393. qh->hw_next = EHCI_LIST_END;
  394. qh->usecs = usecs;
  396. urb->hcpriv = qh_get (qh);
  397. status = -ENOSPC;
  399. /* pick a set of schedule slots, link the QH into them */
  400. do {
  401. int uframe;
  403. /* pick a set of slots such that all uframes have
  404.  * enough periodic bandwidth available.
  405.  *
  406.  * FIXME for TT splits, need uframes for start and end.
  407.  * FSTNs can put end into next frame (uframes 0 or 1).
  408.  */
  409. frame--;
  410. for (uframe = 0; uframe < 8; uframe++) {
  411. if (check_period (ehci, frame, uframe,
  412. period, usecs) != 0)
  413. break;
  414. }
  415. if (uframe == 8)
  416. continue;
  418. /* QH will run once each period, starting there  */
  419. urb->start_frame = frame;
  420. status = 0;
  422. /* set S-frame mask */
  423. qh->hw_info2 |= cpu_to_le32 (1 << uframe);
  424. // dbg_qh ("Schedule INTR qh", ehci, qh);
  426. /* stuff into the periodic schedule */
  427. qh->qh_state = QH_STATE_LINKED;
  428. vdbg ("qh %p usecs %d period %d starting %d.%d",
  429. qh, qh->usecs, period, frame, uframe);
  430. do {
  431. if (unlikely (ehci->pshadow [frame].ptr != 0)) {
  432. // FIXME -- just link toward the end, before any qh with a shorter period,
  433. // AND handle it already being (implicitly) linked into this frame
  434. // AS WELL AS updating the check_period() logic
  435. BUG ();
  436. } else {
  437. ehci->pshadow [frame].qh = qh_get (qh);
  438. ehci->periodic [frame] =
  439. QH_NEXT (qh->qh_dma);
  440. }
  441. wmb ();
  442. frame += period;
  443. } while (frame < ehci->periodic_size);
  445. /* update bandwidth utilization records (for usbfs) */
  446. usb_claim_bandwidth (urb->dev, urb, usecs/period, 0);
  448. /* maybe enable periodic schedule processing */
  449. if (!ehci->periodic_urbs++)
  450. enable_periodic (ehci);
  451. break;
  453. } while (frame);
  454. }
  455. spin_unlock_irqrestore (&ehci->lock, flags);
  456. done:
  457. if (status)
  458. qtd_list_free (ehci, urb, qtd_list);
  460. return status;
  461. }
  463. static unsigned long
  464. intr_complete (
  465. struct ehci_hcd *ehci,
  466. unsigned frame,
  467. struct ehci_qh *qh,
  468. unsigned long flags /* caller owns ehci->lock ... */
  469. ) {
  470. struct ehci_qtd *qtd;
  471. struct urb *urb;
  472. int unlinking;
  474. /* nothing to report? */
  475. if (likely ((qh->hw_token & __constant_cpu_to_le32 (QTD_STS_ACTIVE))
  476. != 0))
  477. return flags;
  478. if (unlikely (list_empty (&qh->qtd_list))) {
  479. dbg ("intr qh %p no TDs?", qh);
  480. return flags;
  481. }
  483. qtd = list_entry (qh->qtd_list.next, struct ehci_qtd, qtd_list);
  484. urb = qtd->urb;
  485. unlinking = (urb->status == -ENOENT) || (urb->status == -ECONNRESET);
  487. /* call any completions, after patching for reactivation */
  488. spin_unlock_irqrestore (&ehci->lock, flags);
  489. /* NOTE:  currently restricted to one qtd per qh! */
  490. if (qh_completions (ehci, qh, 0) == 0)
  491. urb = 0;
  492. spin_lock_irqsave (&ehci->lock, flags);
  494. /* never reactivate requests that were unlinked ... */
  495. if (likely (urb != 0)) {
  496. if (unlinking
  497. || urb->status == -ECONNRESET
  498. || urb->status == -ENOENT
  499. // || (urb->dev == null)
  500. || ehci->hcd.state == USB_STATE_HALT)
  501. urb = 0;
  502. // FIXME look at all those unlink cases ... we always
  503. // need exactly one completion that reports unlink.
  504. // the one above might not have been it!
  505. }
  507. /* normally reactivate */
  508. if (likely (urb != 0)) {
  509. if (usb_pipeout (urb->pipe))
  510. pci_dma_sync_single (ehci->hcd.pdev,
  511. qtd->buf_dma,
  512. urb->transfer_buffer_length,
  513. PCI_DMA_TODEVICE);
  514. urb->status = -EINPROGRESS;
  515. urb->actual_length = 0;
  517. /* patch qh and restart */
  518. qh_update (qh, qtd);
  519. }
  520. return flags;
  521. }
  523. /*-------------------------------------------------------------------------*/
  525. static void
  526. itd_free_list (struct ehci_hcd *ehci, struct urb *urb)
  527. {
  528. struct ehci_itd *first_itd = urb->hcpriv;
  530. pci_unmap_single (ehci->hcd.pdev,
  531. first_itd->buf_dma, urb->transfer_buffer_length,
  532. usb_pipein (urb->pipe)
  533.     ? PCI_DMA_FROMDEVICE
  534.     : PCI_DMA_TODEVICE);
  535. while (!list_empty (&first_itd->itd_list)) {
  536. struct ehci_itd *itd;
  538. itd = list_entry (
  539. first_itd->itd_list.next,
  540. struct ehci_itd, itd_list);
  541. list_del (&itd->itd_list);
  542. pci_pool_free (ehci->itd_pool, itd, itd->itd_dma);
  543. }
  544. pci_pool_free (ehci->itd_pool, first_itd, first_itd->itd_dma);
  545. urb->hcpriv = 0;
  546. }
  548. static int
  549. itd_fill (
  550. struct ehci_hcd *ehci,
  551. struct ehci_itd *itd,
  552. struct urb *urb,
  553. unsigned index, // urb->iso_frame_desc [index]
  554. dma_addr_t dma // mapped transfer buffer
  555. ) {
  556. u64 temp;
  557. u32 buf1;
  558. unsigned i, epnum, maxp, multi;
  559. unsigned length;
  561. itd->hw_next = EHCI_LIST_END;
  562. itd->urb = urb;
  563. itd->index = index;
  565. /* tell itd about its transfer buffer, max 2 pages */
  566. length = urb->iso_frame_desc [index].length;
  567. dma += urb->iso_frame_desc [index].offset;
  568. temp = dma & ~0x0fff;
  569. for (i = 0; i < 2; i++) {
  570. itd->hw_bufp [i] = cpu_to_le32 ((u32) temp);
  571. itd->hw_bufp_hi [i] = cpu_to_le32 ((u32)(temp >> 32));
  572. temp += 0x1000;
  573. }
  574. itd->buf_dma = dma;
  576. /*
  577.  * this might be a "high bandwidth" highspeed endpoint,
  578.  * as encoded in the ep descriptor's maxpacket field
  579.  */
  580. epnum = usb_pipeendpoint (urb->pipe);
  581. if (usb_pipein (urb->pipe)) {
  582. maxp = urb->dev->epmaxpacketin [epnum];
  583. buf1 = (1 << 11);
  584. } else {
  585. maxp = urb->dev->epmaxpacketout [epnum];
  586. buf1 = 0;
  587. }
  588. buf1 |= (maxp & 0x03ff);
  589. multi = 1;
  590. multi += (maxp >> 11) & 0x03;
  591. maxp &= 0x03ff;
  592. maxp *= multi;
  594. /* transfer can't fit in any uframe? */ 
  595. if (length < 0 || maxp < length) {
  596. dbg ("BAD iso packet: %d bytes, max %d, urb %p [%d] (of %d)",
  597. length, maxp, urb, index,
  598. urb->iso_frame_desc [index].length);
  599. return -ENOSPC;
  600. }
  601. itd->usecs = HS_USECS_ISO (length);
  603. /* "plus" info in low order bits of buffer pointers */
  604. itd->hw_bufp [0] |= cpu_to_le32 ((epnum << 8) | urb->dev->devnum);
  605. itd->hw_bufp [1] |= cpu_to_le32 (buf1);
  606. itd->hw_bufp [2] |= cpu_to_le32 (multi);
  608. /* figure hw_transaction[] value (it's scheduled later) */
  609. itd->transaction = EHCI_ISOC_ACTIVE;
  610. itd->transaction |= dma & 0x0fff; /* offset; buffer=0 */
  611. if ((index + 1) == urb->number_of_packets)
  612. itd->transaction |= EHCI_ITD_IOC;  /* end-of-urb irq */
  613. itd->transaction |= length << 16;
  614. cpu_to_le32s (&itd->transaction);
  616. return 0;
  617. }
  619. static int
  620. itd_urb_transaction (
  621. struct ehci_hcd *ehci,
  622. struct urb *urb,
  623. int mem_flags
  624. ) {
  625. int frame_index;
  626. struct ehci_itd *first_itd, *itd;
  627. int status;
  628. dma_addr_t buf_dma, itd_dma;
  630. /* set up one dma mapping for this urb */
  631. buf_dma = pci_map_single (ehci->hcd.pdev,
  632. urb->transfer_buffer, urb->transfer_buffer_length,
  633. usb_pipein (urb->pipe)
  634.     ? PCI_DMA_FROMDEVICE
  635.     : PCI_DMA_TODEVICE);
  636. if (buf_dma == 0)
  637. return -ENOMEM;
  639. /* allocate/init ITDs */
  640. for (frame_index = 0, first_itd = 0;
  641. frame_index < urb->number_of_packets;
  642. frame_index++) {
  643. itd = pci_pool_alloc (ehci->itd_pool, mem_flags, &itd_dma);
  644. if (!itd) {
  645. status = -ENOMEM;
  646. goto fail;
  647. }
  648. memset (itd, 0, sizeof *itd);
  649. itd->itd_dma = itd_dma;
  651. status = itd_fill (ehci, itd, urb, frame_index, buf_dma);
  652. if (status != 0)
  653. goto fail;
  655. if (first_itd)
  656. list_add_tail (&itd->itd_list,
  657. &first_itd->itd_list);
  658. else {
  659. INIT_LIST_HEAD (&itd->itd_list);
  660. urb->hcpriv = first_itd = itd;
  661. }
  662. }
  663. urb->error_count = 0;
  664. return 0;
  666. fail:
  667. if (urb->hcpriv)
  668. itd_free_list (ehci, urb);
  669. return status;
  670. }
  672. /*-------------------------------------------------------------------------*/
  674. static inline void
  675. itd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_itd *itd)
  676. {
  677. /* always prepend ITD/SITD ... only QH tree is order-sensitive */
  678. itd->itd_next = ehci->pshadow [frame];
  679. itd->hw_next = ehci->periodic [frame];
  680. ehci->pshadow [frame].itd = itd;
  681. ehci->periodic [frame] = cpu_to_le32 (itd->itd_dma) | Q_TYPE_ITD;
  682. }
  684. /*
  685.  * return zero on success, else -errno
  686.  * - start holds first uframe to start scheduling into
  687.  * - max is the first uframe it's NOT (!) OK to start scheduling into
  688.  * math to be done modulo "mod" (ehci->periodic_size << 3)
  689.  */
  690. static int get_iso_range (
  691. struct ehci_hcd *ehci,
  692. struct urb *urb,
  693. unsigned *start,
  694. unsigned *max,
  695. unsigned mod
  696. ) {
  697. struct list_head *lh;
  698. struct hcd_dev *dev = urb->dev->hcpriv;
  699. int last = -1;
  700. unsigned now, span, end;
  702. span = urb->interval * urb->number_of_packets;
  704. /* first see if we know when the next transfer SHOULD happen */
  705. list_for_each (lh, &dev->urb_list) {
  706. struct urb *u;
  707. struct ehci_itd *itd;
  708. unsigned s;
  710. u = list_entry (lh, struct urb, urb_list);
  711. if (u == urb || u->pipe != urb->pipe)
  712. continue;
  713. if (u->interval != urb->interval) { /* must not change! */ 
  714. dbg ("urb %p interval %d ... != %p interval %d",
  715. u, u->interval, urb, urb->interval);
  716. return -EINVAL;
  717. }
  719. /* URB for this endpoint... covers through when?  */
  720. itd = urb->hcpriv;
  721. s = itd->uframe + u->interval * u->number_of_packets;
  722. if (last < 0)
  723. last = s;
  724. else {
  725. /*
  726.  * So far we can only queue two ISO URBs...
  727.  *
  728.  * FIXME do interval math, figure out whether
  729.  * this URB is "before" or not ... also, handle
  730.  * the case where the URB might have completed,
  731.  * but hasn't yet been processed.
  732.  */
  733. dbg ("NYET: queue >2 URBs per ISO endpoint");
  734. return -EDOM;
  735. }
  736. }
  738. /* calculate the legal range [start,max) */
  739. now = readl (&ehci->regs->frame_index) + 1; /* next uframe */
  740. if (!ehci->periodic_urbs)
  741. now += 8; /* startup delay */
  742. now %= mod;
  743. end = now + mod;
  744. if (last < 0) {
  745. *start = now + ehci->i_thresh + /* paranoia */ 1;
  746. *max = end - span;
  747. if (*max < *start + 1)
  748. *max = *start + 1;
  749. } else {
  750. *start = last % mod;
  751. *max = (last + 1) % mod;
  752. }
  754. /* explicit start frame? */
  755. if (!(urb->transfer_flags & USB_ISO_ASAP)) {
  756. unsigned temp;
  758. /* sanity check: must be in range */
  759. urb->start_frame %= ehci->periodic_size;
  760. temp = urb->start_frame << 3;
  761. if (temp < *start)
  762. temp += mod;
  763. if (temp > *max)
  764. return -EDOM;
  766. /* use that explicit start frame */
  767. *start = urb->start_frame << 3;
  768. temp += 8;
  769. if (temp < *max)
  770. *max = temp;
  771. }
  773. // FIXME minimize wraparound to "now" ... insist max+span
  774. // (and start+span) remains a few frames short of "end"
  776. *max %= ehci->periodic_size;
  777. if ((*start + span) < end)
  778. return 0;
  779. return -EFBIG;
  780. }
  782. static int
  783. itd_schedule (struct ehci_hcd *ehci, struct urb *urb)
  784. {
  785. unsigned start, max, i;
  786. int status;
  787. unsigned mod = ehci->periodic_size << 3;
  789. for (i = 0; i < urb->number_of_packets; i++) {
  790. urb->iso_frame_desc [i].status = -EINPROGRESS;
  791. urb->iso_frame_desc [i].actual_length = 0;
  792. }
  794. if ((status = get_iso_range (ehci, urb, &start, &max, mod)) != 0)
  795. return status;
  797. do {
  798. unsigned uframe;
  799. unsigned usecs;
  800. struct ehci_itd *itd;
  802. /* check schedule: enough space? */
  803. itd = urb->hcpriv;
  804. uframe = start;
  805. for (i = 0, uframe = start;
  806. i < urb->number_of_packets;
  807. i++, uframe += urb->interval) {
  808. uframe %= mod;
  810. /* can't commit more than 80% periodic == 100 usec */
  811. if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)
  812. > (100 - itd->usecs)) {
  813. itd = 0;
  814. break;
  815. }
  816. itd = list_entry (itd->itd_list.next,
  817. struct ehci_itd, itd_list);
  818. }
  819. if (!itd)
  820. continue;
  822. /* that's where we'll schedule this! */
  823. itd = urb->hcpriv;
  824. urb->start_frame = start >> 3;
  825. vdbg ("ISO urb %p (%d packets period %d) starting %d.%d",
  826. urb, urb->number_of_packets, urb->interval,
  827. urb->start_frame, start & 0x7);
  828. for (i = 0, uframe = start, usecs = 0;
  829. i < urb->number_of_packets;
  830. i++, uframe += urb->interval) {
  831. uframe %= mod;
  833. itd->uframe = uframe;
  834. itd->hw_transaction [uframe & 0x07] = itd->transaction;
  835. itd_link (ehci, (uframe >> 3) % ehci->periodic_size,
  836. itd);
  837. wmb ();
  838. usecs += itd->usecs;
  840. itd = list_entry (itd->itd_list.next,
  841. struct ehci_itd, itd_list);
  842. }
  844. /* update bandwidth utilization records (for usbfs)
  845.  *
  846.  * FIXME This claims each URB queued to an endpoint, as if
  847.  * transfers were concurrent, not sequential.  So bandwidth
  848.  * typically gets double-billed ... comes from tying it to
  849.  * URBs rather than endpoints in the schedule.  Luckily we
  850.  * don't use this usbfs data for serious decision making.
  851.  */
  852. usecs /= urb->number_of_packets;
  853. usecs /= urb->interval;
  854. usecs >>= 3;
  855. if (usecs < 1)
  856. usecs = 1;
  857. usb_claim_bandwidth (urb->dev, urb, usecs, 1);
  859. /* maybe enable periodic schedule processing */
  860. if (!ehci->periodic_urbs++)
  861. enable_periodic (ehci);
  863. return 0;
  865. } while ((start = ++start % mod) != max);
  867. /* no room in the schedule */
  868. dbg ("urb %p, CAN'T SCHEDULE", urb);
  869. return -ENOSPC;
  870. }
  872. /*-------------------------------------------------------------------------*/
  874. #define ISO_ERRS (EHCI_ISOC_BUF_ERR | EHCI_ISOC_BABBLE | EHCI_ISOC_XACTERR)
  876. static unsigned long
  877. itd_complete (
  878. struct ehci_hcd *ehci,
  879. struct ehci_itd *itd,
  880. unsigned uframe,
  881. unsigned long flags
  882. ) {
  883. struct urb *urb = itd->urb;
  884. struct iso_packet_descriptor *desc;
  885. u32 t;
  887. /* update status for this uframe's transfers */
  888. desc = &urb->iso_frame_desc [itd->index];
  890. t = itd->hw_transaction [uframe];
  891. itd->hw_transaction [uframe] = 0;
  892. if (t & EHCI_ISOC_ACTIVE)
  893. desc->status = -EXDEV;
  894. else if (t & ISO_ERRS) {
  895. urb->error_count++;
  896. if (t & EHCI_ISOC_BUF_ERR)
  897. desc->status = usb_pipein (urb->pipe)
  898. ? -ENOSR  /* couldn't read */
  899. : -ECOMM; /* couldn't write */
  900. else if (t & EHCI_ISOC_BABBLE)
  901. desc->status = -EOVERFLOW;
  902. else /* (t & EHCI_ISOC_XACTERR) */
  903. desc->status = -EPROTO;
  905. /* HC need not update length with this error */
  906. if (!(t & EHCI_ISOC_BABBLE))
  907. desc->actual_length += EHCI_ITD_LENGTH (t);
  908. } else {
  909. desc->status = 0;
  910. desc->actual_length += EHCI_ITD_LENGTH (t);
  911. }
  913. vdbg ("itd %p urb %p packet %d/%d trans %x status %d len %d",
  914. itd, urb, itd->index + 1, urb->number_of_packets,
  915. t, desc->status, desc->actual_length);
  917. /* handle completion now? */
  918. if ((itd->index + 1) != urb->number_of_packets)
  919. return flags;
  921. /*
  922.  * Always give the urb back to the driver ... expect it to submit
  923.  * a new urb (or resubmit this), and to have another already queued
  924.  * when un-interrupted transfers are needed.
  925.  *
  926.  * NOTE that for now we don't accelerate ISO unlinks; they just
  927.  * happen according to the current schedule.  Means a delay of
  928.  * up to about a second (max).
  929.  */
  930. itd_free_list (ehci, urb);
  931. if (urb->status == -EINPROGRESS)
  932. urb->status = 0;
  934. spin_unlock_irqrestore (&ehci->lock, flags);
  935. usb_hcd_giveback_urb (&ehci->hcd, urb);
  936. spin_lock_irqsave (&ehci->lock, flags);
  938. /* defer stopping schedule; completion can submit */
  939. ehci->periodic_urbs--;
  940. if (!ehci->periodic_urbs)
  941. disable_periodic (ehci);
  943. return flags;
  944. }
  946. /*-------------------------------------------------------------------------*/
  948. static int itd_submit (struct ehci_hcd *ehci, struct urb *urb, int mem_flags)
  949. {
  950. int status;
  951. unsigned long flags;
  953. dbg ("itd_submit urb %p", urb);
  955. /* NOTE DMA mapping assumes this ... */
  956. if (urb->iso_frame_desc [0].offset != 0)
  957. return -EINVAL;
  959. /* allocate ITDs w/o locking anything */
  960. status = itd_urb_transaction (ehci, urb, mem_flags);
  961. if (status < 0)
  962. return status;
  964. /* schedule ... need to lock */
  965. spin_lock_irqsave (&ehci->lock, flags);
  966. status = itd_schedule (ehci, urb);
  967. spin_unlock_irqrestore (&ehci->lock, flags);
  968. if (status < 0)
  969. itd_free_list (ehci, urb);
  971. return status;
  972. }
  974. #ifdef have_split_iso
  976. /*-------------------------------------------------------------------------*/
  978. /*
  979.  * "Split ISO TDs" ... used for USB 1.1 devices going through
  980.  * the TTs in USB 2.0 hubs.
  981.  */
  983. static void
  984. sitd_free (struct ehci_hcd *ehci, struct ehci_sitd *sitd)
  985. {
  986. pci_pool_free (ehci->sitd_pool, sitd, sitd->sitd_dma);
  987. }
  989. static struct ehci_sitd *
  990. sitd_make (
  991. struct ehci_hcd *ehci,
  992. struct urb *urb,
  993. unsigned index, // urb->iso_frame_desc [index]
  994. unsigned uframe, // scheduled start
  995. dma_addr_t dma, // mapped transfer buffer
  996. int mem_flags
  997. ) {
  998. struct ehci_sitd *sitd;
  999. unsigned length;
  1001. sitd = pci_pool_alloc (ehci->sitd_pool, mem_flags, &dma);
  1002. if (!sitd)
  1003. return sitd;
  1004. sitd->urb = urb;
  1005. length = urb->iso_frame_desc [index].length;
  1006. dma += urb->iso_frame_desc [index].offset;
  1008. #if 0
  1009. // FIXME:  do the rest!
  1010. #else
  1011. sitd_free (ehci, sitd);
  1012. return 0;
  1013. #endif
  1015. }
  1017. static void
  1018. sitd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_sitd *sitd)
  1019. {
  1020. u32 ptr;
  1022. ptr = cpu_to_le32 (sitd->sitd_dma | 2); // type 2 == sitd
  1023. if (ehci->pshadow [frame].ptr) {
  1024. if (!sitd->sitd_next.ptr) {
  1025. sitd->sitd_next = ehci->pshadow [frame];
  1026. sitd->hw_next = ehci->periodic [frame];
  1027. } else if (sitd->sitd_next.ptr != ehci->pshadow [frame].ptr) {
  1028. dbg ("frame %d sitd link goof", frame);
  1029. BUG ();
  1030. }
  1031. }
  1032. ehci->pshadow [frame].sitd = sitd;
  1033. ehci->periodic [frame] = ptr;
  1034. }
  1036. static unsigned long
  1037. sitd_complete (
  1038. struct ehci_hcd *ehci,
  1039. struct ehci_sitd *sitd,
  1040. unsigned long flags
  1041. ) {
  1042. // FIXME -- implement!
  1044. dbg ("NYI -- sitd_complete");
  1045. return flags;
  1046. }
  1048. /*-------------------------------------------------------------------------*/
  1050. static int sitd_submit (struct ehci_hcd *ehci, struct urb *urb, int mem_flags)
  1051. {
  1052. // struct ehci_sitd *first_sitd = 0;
  1053. unsigned frame_index;
  1054. dma_addr_t dma;
  1056. dbg ("NYI -- sitd_submit");
  1058. // FIXME -- implement!
  1060. // FIXME:  setup one big dma mapping
  1061. dma = 0;
  1063. for (frame_index = 0;
  1064. frame_index < urb->number_of_packets;
  1065. frame_index++) {
  1066. struct ehci_sitd *sitd;
  1067. unsigned uframe;
  1069. // FIXME:  use real arguments, schedule this!
  1070. uframe = -1;
  1072. sitd = sitd_make (ehci, urb, frame_index,
  1073. uframe, dma, mem_flags);
  1075. if (sitd) {
  1076.     /*
  1077. if (first_sitd)
  1078. list_add_tail (&sitd->sitd_list,
  1079. &first_sitd->sitd_list);
  1080. else
  1081. first_sitd = sitd;
  1082.     */
  1083. } else {
  1084. // FIXME:  clean everything up
  1085. }
  1086. }
  1088. // if we have a first sitd, then
  1089. // store them all into the periodic schedule!
  1090. // urb->hcpriv = first sitd in sitd_list
  1092. return -ENOSYS;
  1093. }
  1094. #endif /* have_split_iso */
  1096. /*-------------------------------------------------------------------------*/
  1098. static void scan_periodic (struct ehci_hcd *ehci)
  1099. {
  1100. unsigned frame, clock, now_uframe, mod;
  1101. unsigned long flags;
  1103. mod = ehci->periodic_size << 3;
  1104. spin_lock_irqsave (&ehci->lock, flags);
  1106. /*
  1107.  * When running, scan from last scan point up to "now"
  1108.  * else clean up by scanning everything that's left.
  1109.  * Touches as few pages as possible:  cache-friendly.
  1110.  * Don't scan ISO entries more than once, though.
  1111.  */
  1112. frame = ehci->next_uframe >> 3;
  1113. if (HCD_IS_RUNNING (ehci->hcd.state))
  1114. now_uframe = readl (&ehci->regs->frame_index);
  1115. else
  1116. now_uframe = (frame << 3) - 1;
  1117. now_uframe %= mod;
  1118. clock = now_uframe >> 3;
  1120. for (;;) {
  1121. union ehci_shadow q, *q_p;
  1122. u32 type, *hw_p;
  1123. unsigned uframes;
  1125. restart:
  1126. /* scan schedule to _before_ current frame index */
  1127. if (frame == clock)
  1128. uframes = now_uframe & 0x07;
  1129. else
  1130. uframes = 8;
  1132. q_p = &ehci->pshadow [frame];
  1133. hw_p = &ehci->periodic [frame];
  1134. q.ptr = q_p->ptr;
  1135. type = Q_NEXT_TYPE (*hw_p);
  1137. /* scan each element in frame's queue for completions */
  1138. while (q.ptr != 0) {
  1139. int last;
  1140. unsigned uf;
  1141. union ehci_shadow temp;
  1143. switch (type) {
  1144. case Q_TYPE_QH:
  1145. last = (q.qh->hw_next == EHCI_LIST_END);
  1146. temp = q.qh->qh_next;
  1147. type = Q_NEXT_TYPE (q.qh->hw_next);
  1148. flags = intr_complete (ehci, frame,
  1149. qh_get (q.qh), flags);
  1150. qh_put (ehci, q.qh);
  1151. q = temp;
  1152. break;
  1153. case Q_TYPE_FSTN:
  1154. last = (q.fstn->hw_next == EHCI_LIST_END);
  1155. /* for "save place" FSTNs, look at QH entries
  1156.  * in the previous frame for completions.
  1157.  */
  1158. if (q.fstn->hw_prev != EHCI_LIST_END) {
  1159. dbg ("ignoring completions from FSTNs");
  1160. }
  1161. type = Q_NEXT_TYPE (q.fstn->hw_next);
  1162. q = q.fstn->fstn_next;
  1163. break;
  1164. case Q_TYPE_ITD:
  1165. last = (q.itd->hw_next == EHCI_LIST_END);
  1167. /* Unlink each (S)ITD we see, since the ISO
  1168.  * URB model forces constant rescheduling.
  1169.  * That complicates sharing uframes in ITDs,
  1170.  * and means we need to skip uframes the HC
  1171.  * hasn't yet processed.
  1172.  */
  1173. for (uf = 0; uf < uframes; uf++) {
  1174. if (q.itd->hw_transaction [uf] != 0) {
  1175. temp = q;
  1176. *q_p = q.itd->itd_next;
  1177. *hw_p = q.itd->hw_next;
  1178. type = Q_NEXT_TYPE (*hw_p);
  1180. /* might free q.itd ... */
  1181. flags = itd_complete (ehci,
  1182. temp.itd, uf, flags);
  1183. break;
  1184. }
  1185. }
  1186. /* we might skip this ITD's uframe ... */
  1187. if (uf == uframes) {
  1188. q_p = &q.itd->itd_next;
  1189. hw_p = &q.itd->hw_next;
  1190. type = Q_NEXT_TYPE (q.itd->hw_next);
  1191. }
  1193. q = *q_p;
  1194. break;
  1195. #ifdef have_split_iso
  1196. case Q_TYPE_SITD:
  1197. last = (q.sitd->hw_next == EHCI_LIST_END);
  1198. flags = sitd_complete (ehci, q.sitd, flags);
  1199. type = Q_NEXT_TYPE (q.sitd->hw_next);
  1201. // FIXME unlink SITD after split completes
  1202. q = q.sitd->sitd_next;
  1203. break;
  1204. #endif /* have_split_iso */
  1205. default:
  1206. dbg ("corrupt type %d frame %d shadow %p",
  1207. type, frame, q.ptr);
  1208. // BUG ();
  1209. last = 1;
  1210. q.ptr = 0;
  1211. }
  1213. /* did completion remove an interior q entry? */
  1214. if (unlikely (q.ptr == 0 && !last))
  1215. goto restart;
  1216. }
  1218. /* stop when we catch up to the HC */
  1220. // FIXME:  this assumes we won't get lapped when
  1221. // latencies climb; that should be rare, but...
  1222. // detect it, and just go all the way around.
  1223. // FLR might help detect this case, so long as latencies
  1224. // don't exceed periodic_size msec (default 1.024 sec).
  1226. // FIXME:  likewise assumes HC doesn't halt mid-scan
  1228. if (frame == clock) {
  1229. unsigned now;
  1231. if (!HCD_IS_RUNNING (ehci->hcd.state))
  1232. break;
  1233. ehci->next_uframe = now_uframe;
  1234. now = readl (&ehci->regs->frame_index) % mod;
  1235. if (now_uframe == now)
  1236. break;
  1238. /* rescan the rest of this frame, then ... */
  1239. now_uframe = now;
  1240. clock = now_uframe >> 3;
  1241. } else
  1242. frame = (frame + 1) % ehci->periodic_size;
  1243. } 
  1244. spin_unlock_irqrestore (&ehci->lock, flags);
  1245. }