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

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

Linux/Unix编程

开发平台：

Unix_Linux

ehci-q.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 hardware queue manipulation ... the core.  QH/QTD manipulation.
  25.  *
  26.  * Control, bulk, and interrupt traffic all use "qh" lists.  They list "qtd"
  27.  * entries describing USB transactions, max 16-20kB/entry (with 4kB-aligned
  28.  * buffers needed for the larger number).  We use one QH per endpoint, queue
  29.  * multiple (bulk or control) urbs per endpoint.  URBs may need several qtds.
  30.  * A scheduled interrupt qh always (for now) has one qtd, one urb.
  31.  *
  32.  * ISO traffic uses "ISO TD" (itd, and sitd) records, and (along with
  33.  * interrupts) needs careful scheduling.  Performance improvements can be
  34.  * an ongoing challenge.  That's in "ehci-sched.c".
  35.  * 
  36.  * USB 1.1 devices are handled (a) by "companion" OHCI or UHCI root hubs,
  37.  * or otherwise through transaction translators (TTs) in USB 2.0 hubs using
  38.  * (b) special fields in qh entries or (c) split iso entries.  TTs will
  39.  * buffer low/full speed data so the host collects it at high speed.
  40.  */
  42. /*-------------------------------------------------------------------------*/
  44. /* fill a qtd, returning how much of the buffer we were able to queue up */
  46. static int
  47. qtd_fill (struct ehci_qtd *qtd, dma_addr_t buf, size_t len, int token)
  48. {
  49. int i, count;
  51. /* one buffer entry per 4K ... first might be short or unaligned */
  52. qtd->hw_buf [0] = cpu_to_le32 (buf);
  53. count = 0x1000 - (buf & 0x0fff); /* rest of that page */
  54. if (likely (len < count)) /* ... iff needed */
  55. count = len;
  56. else {
  57. buf +=  0x1000;
  58. buf &= ~0x0fff;
  60. /* per-qtd limit: from 16K to 20K (best alignment) */
  61. for (i = 1; count < len && i < 5; i++) {
  62. u64 addr = buf;
  63. qtd->hw_buf [i] = cpu_to_le32 ((u32)addr);
  64. qtd->hw_buf_hi [i] = cpu_to_le32 ((u32)(addr >> 32));
  65. buf += 0x1000;
  66. if ((count + 0x1000) < len)
  67. count += 0x1000;
  68. else
  69. count = len;
  70. }
  71. }
  72. qtd->hw_token = cpu_to_le32 ((count << 16) | token);
  73. qtd->length = count;
  75. #if 0
  76. vdbg ("  qtd_fill %p, token %8x bytes %d dma %x",
  77. qtd, le32_to_cpu (qtd->hw_token), count, qtd->hw_buf [0]);
  78. #endif
  80. return count;
  81. }
  83. /*-------------------------------------------------------------------------*/
  85. /* update halted (but potentially linked) qh */
  87. static inline void qh_update (struct ehci_qh *qh, struct ehci_qtd *qtd)
  88. {
  89. qh->hw_current = 0;
  90. qh->hw_qtd_next = QTD_NEXT (qtd->qtd_dma);
  91. qh->hw_alt_next = EHCI_LIST_END;
  93. /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
  94. wmb ();
  95. qh->hw_token &= __constant_cpu_to_le32 (QTD_TOGGLE | QTD_STS_PING);
  96. }
  98. /*-------------------------------------------------------------------------*/
  100. static inline void qtd_copy_status (struct urb *urb, size_t length, u32 token)
  101. {
  102. /* count IN/OUT bytes, not SETUP (even short packets) */
  103. if (likely (QTD_PID (token) != 2))
  104. urb->actual_length += length - QTD_LENGTH (token);
  106. /* don't modify error codes */
  107. if (unlikely (urb->status == -EINPROGRESS && (token & QTD_STS_HALT))) {
  108. if (token & QTD_STS_BABBLE) {
  109. /* FIXME "must" disable babbling device's port too */
  110. urb->status = -EOVERFLOW;
  111. } else if (token & QTD_STS_MMF) {
  112. /* fs/ls interrupt xfer missed the complete-split */
  113. urb->status = -EPROTO;
  114. } else if (token & QTD_STS_DBE) {
  115. urb->status = (QTD_PID (token) == 1) /* IN ? */
  116. ? -ENOSR  /* hc couldn't read data */
  117. : -ECOMM; /* hc couldn't write data */
  118. } else if (token & QTD_STS_XACT) {
  119. /* timeout, bad crc, wrong PID, etc; retried */
  120. if (QTD_CERR (token))
  121. urb->status = -EPIPE;
  122. else {
  123. dbg ("3strikes");
  124. urb->status = -EPROTO;
  125. }
  126. /* CERR nonzero + no errors + halt --> stall */
  127. } else if (QTD_CERR (token))
  128. urb->status = -EPIPE;
  129. else /* unknown */
  130. urb->status = -EPROTO;
  132. dbg ("ep %d-%s qtd token %08x --> status %d",
  133. /* devpath */
  134. usb_pipeendpoint (urb->pipe),
  135. usb_pipein (urb->pipe) ? "in" : "out",
  136. token, urb->status);
  138. /* stall indicates some recovery action is needed */
  139. if (urb->status == -EPIPE) {
  140. int pipe = urb->pipe;
  142. if (!usb_pipecontrol (pipe))
  143. usb_endpoint_halt (urb->dev,
  144. usb_pipeendpoint (pipe),
  145. usb_pipeout (pipe));
  146. if (urb->dev->tt && !usb_pipeint (pipe)) {
  147. err ("must CLEAR_TT_BUFFER, hub port %d%s addr %d ep %d",
  148.     urb->dev->ttport, /* devpath */
  149.     urb->dev->tt->multi ? "" : " (all-ports TT)",
  150.     urb->dev->devnum, usb_pipeendpoint (urb->pipe));
  151. // FIXME something (khubd?) should make the hub
  152. // CLEAR_TT_BUFFER ASAP, it's blocking other
  153. // fs/ls requests... hub_tt_clear_buffer() ?
  154. }
  155. }
  156. }
  157. }
  159. static void ehci_urb_complete (
  160. struct ehci_hcd *ehci,
  161. dma_addr_t addr,
  162. struct urb *urb
  163. ) {
  164. if (urb->transfer_buffer_length && usb_pipein (urb->pipe))
  165. pci_dma_sync_single (ehci->hcd.pdev, addr,
  166. urb->transfer_buffer_length,
  167. PCI_DMA_FROMDEVICE);
  169. /* cleanse status if we saw no error */
  170. if (likely (urb->status == -EINPROGRESS)) {
  171. if (urb->actual_length != urb->transfer_buffer_length
  172. && (urb->transfer_flags & USB_DISABLE_SPD))
  173. urb->status = -EREMOTEIO;
  174. else
  175. urb->status = 0;
  176. }
  178. /* only report unlinks once */
  179. if (likely (urb->status != -ENOENT && urb->status != -ENOTCONN))
  180. urb->complete (urb);
  181. }
  183. /* urb->lock ignored from here on (hcd is done with urb) */
  185. static void ehci_urb_done (
  186. struct ehci_hcd *ehci,
  187. dma_addr_t addr,
  188. struct urb *urb
  189. ) {
  190. if (urb->transfer_buffer_length)
  191. pci_unmap_single (ehci->hcd.pdev,
  192. addr,
  193. urb->transfer_buffer_length,
  194. usb_pipein (urb->pipe)
  195.     ? PCI_DMA_FROMDEVICE
  196.     : PCI_DMA_TODEVICE);
  197. if (likely (urb->hcpriv != 0)) {
  198. qh_put (ehci, (struct ehci_qh *) urb->hcpriv);
  199. urb->hcpriv = 0;
  200. }
  202. if (likely (urb->status == -EINPROGRESS)) {
  203. if (urb->actual_length != urb->transfer_buffer_length
  204. && (urb->transfer_flags & USB_DISABLE_SPD))
  205. urb->status = -EREMOTEIO;
  206. else
  207. urb->status = 0;
  208. }
  210. /* hand off urb ownership */
  211. usb_hcd_giveback_urb (&ehci->hcd, urb);
  212. }
  215. /*
  216.  * Process completed qtds for a qh, issuing completions if needed.
  217.  * When freeing:  frees qtds, unmaps buf, returns URB to driver.
  218.  * When not freeing (queued periodic qh):  retain qtds, mapping, and urb.
  219.  * Races up to qh->hw_current; returns number of urb completions.
  220.  */
  221. static int
  222. qh_completions (
  223. struct ehci_hcd *ehci,
  224. struct ehci_qh *qh,
  225. int freeing
  226. ) {
  227. struct ehci_qtd *qtd, *last;
  228. struct list_head *next, *qtd_list = &qh->qtd_list;
  229. int unlink = 0, halted = 0;
  230. unsigned long flags;
  231. int retval = 0;
  233. spin_lock_irqsave (&ehci->lock, flags);
  234. if (unlikely (list_empty (qtd_list))) {
  235. spin_unlock_irqrestore (&ehci->lock, flags);
  236. return retval;
  237. }
  239. /* scan QTDs till end of list, or we reach an active one */
  240. for (qtd = list_entry (qtd_list->next, struct ehci_qtd, qtd_list),
  241.      last = 0, next = 0;
  242. next != qtd_list;
  243. last = qtd, qtd = list_entry (next,
  244. struct ehci_qtd, qtd_list)) {
  245. struct urb *urb = qtd->urb;
  246. u32 token = 0;
  248. /* clean up any state from previous QTD ...*/
  249. if (last) {
  250. if (likely (last->urb != urb)) {
  251. /* complete() can reenter this HCD */
  252. spin_unlock_irqrestore (&ehci->lock, flags);
  253. if (likely (freeing != 0))
  254. ehci_urb_done (ehci, last->buf_dma,
  255. last->urb);
  256. else
  257. ehci_urb_complete (ehci, last->buf_dma,
  258. last->urb);
  259. spin_lock_irqsave (&ehci->lock, flags);
  260. retval++;
  261. }
  263. /* qh overlays can have HC's old cached copies of
  264.  * next qtd ptrs, if an URB was queued afterwards.
  265.  */
  266. if (cpu_to_le32 (last->qtd_dma) == qh->hw_current
  267. && last->hw_next != qh->hw_qtd_next) {
  268. qh->hw_alt_next = last->hw_alt_next;
  269. qh->hw_qtd_next = last->hw_next;
  270. }
  272. if (likely (freeing != 0))
  273. ehci_qtd_free (ehci, last);
  274. last = 0;
  275. }
  276. next = qtd->qtd_list.next;
  278. /* QTDs at tail may be active if QH+HC are running,
  279.  * or when unlinking some urbs queued to this QH
  280.  */
  281. token = le32_to_cpu (qtd->hw_token);
  282. halted = halted
  283. || (__constant_cpu_to_le32 (QTD_STS_HALT)
  284. & qh->hw_token) != 0
  285. || (ehci->hcd.state == USB_STATE_HALT)
  286. || (qh->qh_state == QH_STATE_IDLE);
  288. /* fault: unlink the rest, since this qtd saw an error? */
  289. if (unlikely ((token & QTD_STS_HALT) != 0)) {
  290. freeing = unlink = 1;
  291. /* status copied below */
  293. /* QH halts only because of fault (above) or unlink (here). */
  294. } else if (unlikely (halted != 0)) {
  296. /* unlinking everything because of HC shutdown? */
  297. if (ehci->hcd.state == USB_STATE_HALT) {
  298. freeing = unlink = 1;
  300. /* explicit unlink, maybe starting here? */
  301. } else if (qh->qh_state == QH_STATE_IDLE
  302. && (urb->status == -ECONNRESET
  303. || urb->status == -ENOENT)) {
  304. freeing = unlink = 1;
  306. /* QH halted to unlink urbs _after_ this?  */
  307. } else if (!unlink && (token & QTD_STS_ACTIVE) != 0) {
  308. qtd = 0;
  309. continue;
  310. }
  312. /* unlink the rest?  once we start unlinking, after
  313.  * a fault or explicit unlink, we unlink all later
  314.  * urbs.  usb spec requires that.
  315.  */
  316. if (unlink && urb->status == -EINPROGRESS)
  317. urb->status = -ECONNRESET;
  319. /* Else QH is active, so we must not modify QTDs
  320.  * that HC may be working on.  No more qtds to check.
  321.  */
  322. } else if (unlikely ((token & QTD_STS_ACTIVE) != 0)) {
  323. next = qtd_list;
  324. qtd = 0;
  325. continue;
  326. }
  328. spin_lock (&urb->lock);
  329. qtd_copy_status (urb, qtd->length, token);
  330. spin_unlock (&urb->lock);
  332. /*
  333.  * NOTE:  this won't work right with interrupt urbs that
  334.  * need multiple qtds ... only the first scan of qh->qtd_list
  335.  * starts at the right qtd, yet multiple scans could happen
  336.  * for transfers that are scheduled across multiple uframes. 
  337.  * (Such schedules are not currently allowed!)
  338.  */
  339. if (likely (freeing != 0))
  340. list_del (&qtd->qtd_list);
  341. else {
  342. /* restore everything the HC could change
  343.  * from an interrupt QTD
  344.  */
  345. qtd->hw_token = (qtd->hw_token
  346. & __constant_cpu_to_le32 (0x8300))
  347. | cpu_to_le32 (qtd->length << 16)
  348. | __constant_cpu_to_le32 (QTD_STS_ACTIVE
  349. | (EHCI_TUNE_CERR << 10));
  350. qtd->hw_buf [0] &= ~__constant_cpu_to_le32 (0x0fff);
  352. /* this offset, and the length above,
  353.  * are likely wrong on QTDs #2..N
  354.  */
  355. qtd->hw_buf [0] |= cpu_to_le32 (0x0fff & qtd->buf_dma);
  356. }
  358. #if 0
  359. if (urb->status == -EINPROGRESS)
  360. vdbg ("  qtd %p ok, urb %p, token %8x, len %d",
  361. qtd, urb, token, urb->actual_length);
  362. else
  363. vdbg ("urb %p status %d, qtd %p, token %8x, len %d",
  364. urb, urb->status, qtd, token,
  365. urb->actual_length);
  366. #endif
  368. /* SETUP for control urb? */
  369. if (unlikely (QTD_PID (token) == 2))
  370. pci_unmap_single (ehci->hcd.pdev,
  371. qtd->buf_dma, sizeof (struct usb_ctrlrequest),
  372. PCI_DMA_TODEVICE);
  373. }
  375. /* patch up list head? */
  376. if (unlikely (halted && !list_empty (qtd_list))) {
  377. qh_update (qh, list_entry (qtd_list->next,
  378. struct ehci_qtd, qtd_list));
  379. }
  380. spin_unlock_irqrestore (&ehci->lock, flags);
  382. /* last urb's completion might still need calling */
  383. if (likely (last != 0)) {
  384. if (likely (freeing != 0)) {
  385. ehci_urb_done (ehci, last->buf_dma, last->urb);
  386. ehci_qtd_free (ehci, last);
  387. } else
  388. ehci_urb_complete (ehci, last->buf_dma, last->urb);
  389. retval++;
  390. }
  391. return retval;
  392. }
  394. /*-------------------------------------------------------------------------*/
  396. /*
  397.  * reverse of qh_urb_transaction:  free a list of TDs.
  398.  * used for cleanup after errors, before HC sees an URB's TDs.
  399.  */
  400. static void qtd_list_free (
  401. struct ehci_hcd *ehci,
  402. struct urb *urb,
  403. struct list_head *qtd_list
  404. ) {
  405. struct list_head *entry, *temp;
  406. int unmapped = 0;
  408. list_for_each_safe (entry, temp, qtd_list) {
  409. struct ehci_qtd *qtd;
  411. qtd = list_entry (entry, struct ehci_qtd, qtd_list);
  412. list_del (&qtd->qtd_list);
  413. if (unmapped != 2) {
  414. int direction;
  415. size_t size;
  417. /* for ctrl unmap twice: SETUP and DATA;
  418.  * else (bulk, intr) just once: DATA
  419.  */
  420. if (!unmapped++ && usb_pipecontrol (urb->pipe)) {
  421. direction = PCI_DMA_TODEVICE;
  422. size = sizeof (struct usb_ctrlrequest);
  423. } else {
  424. direction = usb_pipein (urb->pipe)
  425. ? PCI_DMA_FROMDEVICE
  426. : PCI_DMA_TODEVICE;
  427. size = qtd->urb->transfer_buffer_length;
  428. unmapped++;
  429. }
  430. if (qtd->buf_dma)
  431. pci_unmap_single (ehci->hcd.pdev,
  432. qtd->buf_dma,
  433. size, direction);
  434. }
  435. ehci_qtd_free (ehci, qtd);
  436. }
  437. }
  439. /*
  440.  * create a list of filled qtds for this URB; won't link into qh.
  441.  */
  442. static struct list_head *
  443. qh_urb_transaction (
  444. struct ehci_hcd *ehci,
  445. struct urb *urb,
  446. struct list_head *head,
  447. int flags
  448. ) {
  449. struct ehci_qtd *qtd, *qtd_prev;
  450. dma_addr_t buf, map_buf;
  451. int len, maxpacket;
  452. u32 token;
  454. /*
  455.  * URBs map to sequences of QTDs:  one logical transaction
  456.  */
  457. qtd = ehci_qtd_alloc (ehci, flags);
  458. if (unlikely (!qtd))
  459. return 0;
  460. qtd_prev = 0;
  461. list_add_tail (&qtd->qtd_list, head);
  462. qtd->urb = urb;
  464. token = QTD_STS_ACTIVE;
  465. token |= (EHCI_TUNE_CERR << 10);
  466. /* for split transactions, SplitXState initialized to zero */
  468. if (usb_pipecontrol (urb->pipe)) {
  469. /* control request data is passed in the "setup" pid */
  470. qtd->buf_dma = pci_map_single (
  471. ehci->hcd.pdev,
  472. urb->setup_packet,
  473. sizeof (struct usb_ctrlrequest),
  474. PCI_DMA_TODEVICE);
  475. if (unlikely (!qtd->buf_dma))
  476. goto cleanup;
  478. /* SETUP pid */
  479. qtd_fill (qtd, qtd->buf_dma, sizeof (struct usb_ctrlrequest),
  480. token | (2 /* "setup" */ << 8));
  482. /* ... and always at least one more pid */
  483. token ^= QTD_TOGGLE;
  484. qtd_prev = qtd;
  485. qtd = ehci_qtd_alloc (ehci, flags);
  486. if (unlikely (!qtd))
  487. goto cleanup;
  488. qtd->urb = urb;
  489. qtd_prev->hw_next = QTD_NEXT (qtd->qtd_dma);
  490. list_add_tail (&qtd->qtd_list, head);
  491. } 
  493. /*
  494.  * data transfer stage:  buffer setup
  495.  */
  496. len = urb->transfer_buffer_length;
  497. if (likely (len > 0)) {
  498. buf = map_buf = pci_map_single (ehci->hcd.pdev,
  499. urb->transfer_buffer, len,
  500. usb_pipein (urb->pipe)
  501.     ? PCI_DMA_FROMDEVICE
  502.     : PCI_DMA_TODEVICE);
  503. if (unlikely (!buf))
  504. goto cleanup;
  505. } else
  506. buf = map_buf = 0;
  508. if (!buf || usb_pipein (urb->pipe))
  509. token |= (1 /* "in" */ << 8);
  510. /* else it's already initted to "out" pid (0 << 8) */
  512. maxpacket = usb_maxpacket (urb->dev, urb->pipe,
  513. usb_pipeout (urb->pipe));
  515. /*
  516.  * buffer gets wrapped in one or more qtds;
  517.  * last one may be "short" (including zero len)
  518.  * and may serve as a control status ack
  519.  */
  520. for (;;) {
  521. int this_qtd_len;
  523. qtd->urb = urb;
  524. qtd->buf_dma = map_buf;
  525. this_qtd_len = qtd_fill (qtd, buf, len, token);
  526. len -= this_qtd_len;
  527. buf += this_qtd_len;
  529. /* qh makes control packets use qtd toggle; maybe switch it */
  530. if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
  531. token ^= QTD_TOGGLE;
  533. if (likely (len <= 0))
  534. break;
  536. qtd_prev = qtd;
  537. qtd = ehci_qtd_alloc (ehci, flags);
  538. if (unlikely (!qtd))
  539. goto cleanup;
  540. qtd->urb = urb;
  541. qtd_prev->hw_next = QTD_NEXT (qtd->qtd_dma);
  542. list_add_tail (&qtd->qtd_list, head);
  543. }
  545. /*
  546.  * control requests may need a terminating data "status" ack;
  547.  * bulk ones may need a terminating short packet (zero length).
  548.  */
  549. if (likely (buf != 0)) {
  550. int one_more = 0;
  552. if (usb_pipecontrol (urb->pipe)) {
  553. one_more = 1;
  554. token ^= 0x0100; /* "in" <--> "out"  */
  555. token |= QTD_TOGGLE; /* force DATA1 */
  556. } else if (usb_pipebulk (urb->pipe)
  557. && (urb->transfer_flags & USB_ZERO_PACKET)
  558. && !(urb->transfer_buffer_length % maxpacket)) {
  559. one_more = 1;
  560. }
  561. if (one_more) {
  562. qtd_prev = qtd;
  563. qtd = ehci_qtd_alloc (ehci, flags);
  564. if (unlikely (!qtd))
  565. goto cleanup;
  566. qtd->urb = urb;
  567. qtd_prev->hw_next = QTD_NEXT (qtd->qtd_dma);
  568. list_add_tail (&qtd->qtd_list, head);
  570. /* never any data in such packets */
  571. qtd_fill (qtd, 0, 0, token);
  572. }
  573. }
  575. /* by default, enable interrupt on urb completion */
  576. if (likely (!(urb->transfer_flags & URB_NO_INTERRUPT)))
  577. qtd->hw_token |= __constant_cpu_to_le32 (QTD_IOC);
  578. return head;
  580. cleanup:
  581. qtd_list_free (ehci, urb, head);
  582. return 0;
  583. }
  585. /*-------------------------------------------------------------------------*/
  587. /*
  588.  * Hardware maintains data toggle (like OHCI) ... here we (re)initialize
  589.  * the hardware data toggle in the QH, and set the pseudo-toggle in udev
  590.  * so we can see if usb_clear_halt() was called.  NOP for control, since
  591.  * we set up qh->hw_info1 to always use the QTD toggle bits. 
  592.  */
  593. static inline void
  594. clear_toggle (struct usb_device *udev, int ep, int is_out, struct ehci_qh *qh)
  595. {
  596. vdbg ("clear toggle, dev %d ep 0x%x-%s",
  597. udev->devnum, ep, is_out ? "out" : "in");
  598. qh->hw_token &= ~__constant_cpu_to_le32 (QTD_TOGGLE);
  599. usb_settoggle (udev, ep, is_out, 1);
  600. }
  602. // Would be best to create all qh's from config descriptors,
  603. // when each interface/altsetting is established.  Unlink
  604. // any previous qh and cancel its urbs first; endpoints are
  605. // implicitly reset then (data toggle too).
  606. // That'd mean updating how usbcore talks to HCDs. (2.5?)
  609. /*
  610.  * Each QH holds a qtd list; a QH is used for everything except iso.
  611.  *
  612.  * For interrupt urbs, the scheduler must set the microframe scheduling
  613.  * mask(s) each time the QH gets scheduled.  For highspeed, that's
  614.  * just one microframe in the s-mask.  For split interrupt transactions
  615.  * there are additional complications: c-mask, maybe FSTNs.
  616.  */
  617. static struct ehci_qh *
  618. ehci_qh_make (
  619. struct ehci_hcd *ehci,
  620. struct urb *urb,
  621. struct list_head *qtd_list,
  622. int flags
  623. ) {
  624. struct ehci_qh *qh = ehci_qh_alloc (ehci, flags);
  625. u32 info1 = 0, info2 = 0;
  627. if (!qh)
  628. return qh;
  630. /*
  631.  * init endpoint/device data for this QH
  632.  */
  633. info1 |= usb_pipeendpoint (urb->pipe) << 8;
  634. info1 |= usb_pipedevice (urb->pipe) << 0;
  636. /* using TT? */
  637. switch (urb->dev->speed) {
  638. case USB_SPEED_LOW:
  639. info1 |= (1 << 12); /* EPS "low" */
  640. /* FALL THROUGH */
  642. case USB_SPEED_FULL:
  643. /* EPS 0 means "full" */
  644. info1 |= (EHCI_TUNE_RL_TT << 28);
  645. if (usb_pipecontrol (urb->pipe)) {
  646. info1 |= (1 << 27); /* for TT */
  647. info1 |= 1 << 14; /* toggle from qtd */
  648. }
  649. info1 |= usb_maxpacket (urb->dev, urb->pipe,
  650. usb_pipeout (urb->pipe)) << 16;
  652. info2 |= (EHCI_TUNE_MULT_TT << 30);
  653. info2 |= urb->dev->ttport << 23;
  654. info2 |= urb->dev->tt->hub->devnum << 16;
  656. /* NOTE:  if (usb_pipeint (urb->pipe)) { scheduler sets c-mask }
  657.  * ... and a 0.96 scheduler might use FSTN nodes too
  658.  */
  659. break;
  661. case USB_SPEED_HIGH: /* no TT involved */
  662. info1 |= (2 << 12); /* EPS "high" */
  663. info1 |= (EHCI_TUNE_RL_HS << 28);
  664. if (usb_pipecontrol (urb->pipe)) {
  665. info1 |= 64 << 16; /* usb2 fixed maxpacket */
  666. info1 |= 1 << 14; /* toggle from qtd */
  667. info2 |= (EHCI_TUNE_MULT_HS << 30);
  668. } else if (usb_pipebulk (urb->pipe)) {
  669. info1 |= 512 << 16; /* usb2 fixed maxpacket */
  670. info2 |= (EHCI_TUNE_MULT_HS << 30);
  671. } else {
  672. u32 temp;
  673. temp = usb_maxpacket (urb->dev, urb->pipe,
  674. usb_pipeout (urb->pipe));
  675. info1 |= (temp & 0x3ff) << 16; /* maxpacket */
  676. /* HS intr can be "high bandwidth" */
  677. temp = 1 + ((temp >> 11) & 0x03);
  678. info2 |= temp << 30; /* mult */
  679. }
  680. break;
  681. default:
  682. #ifdef DEBUG
  683. BUG ();
  684. #else
  685. ;
  686. #endif
  687. }
  689. /* NOTE:  if (usb_pipeint (urb->pipe)) { scheduler sets s-mask } */
  691. qh->qh_state = QH_STATE_IDLE;
  692. qh->hw_info1 = cpu_to_le32 (info1);
  693. qh->hw_info2 = cpu_to_le32 (info2);
  695. /* initialize sw and hw queues with these qtds */
  696. list_splice (qtd_list, &qh->qtd_list);
  697. qh_update (qh, list_entry (qtd_list->next, struct ehci_qtd, qtd_list));
  699. /* initialize data toggle state */
  700. if (!usb_pipecontrol (urb->pipe))
  701. clear_toggle (urb->dev,
  702. usb_pipeendpoint (urb->pipe),
  703. usb_pipeout (urb->pipe),
  704. qh);
  706. return qh;
  707. }
  709. /*-------------------------------------------------------------------------*/
  711. /* move qh (and its qtds) onto async queue; maybe enable queue.  */
  713. static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
  714. {
  715. u32 dma = QH_NEXT (qh->qh_dma);
  716. struct ehci_qh *q;
  718. if (unlikely (!(q = ehci->async))) {
  719. u32 cmd = readl (&ehci->regs->command);
  721. /* in case a clear of CMD_ASE didn't take yet */
  722. while (readl (&ehci->regs->status) & STS_ASS)
  723. udelay (100);
  725. qh->hw_info1 |= __constant_cpu_to_le32 (QH_HEAD); /* [4.8] */
  726. qh->qh_next.qh = qh;
  727. qh->hw_next = dma;
  728. wmb ();
  729. ehci->async = qh;
  730. writel ((u32)qh->qh_dma, &ehci->regs->async_next);
  731. cmd |= CMD_ASE | CMD_RUN;
  732. writel (cmd, &ehci->regs->command);
  733. ehci->hcd.state = USB_STATE_RUNNING;
  734. /* posted write need not be known to HC yet ... */
  735. } else {
  736. /* splice right after "start" of ring */
  737. qh->hw_info1 &= ~__constant_cpu_to_le32 (QH_HEAD); /* [4.8] */
  738. qh->qh_next = q->qh_next;
  739. qh->hw_next = q->hw_next;
  740. wmb ();
  741. q->qh_next.qh = qh;
  742. q->hw_next = dma;
  743. }
  744. qh->qh_state = QH_STATE_LINKED;
  745. /* qtd completions reported later by interrupt */
  746. }
  748. /*-------------------------------------------------------------------------*/
  750. static int
  751. submit_async (
  752. struct ehci_hcd *ehci,
  753. struct urb *urb,
  754. struct list_head *qtd_list,
  755. int mem_flags
  756. ) {
  757. struct ehci_qtd *qtd;
  758. struct hcd_dev *dev;
  759. int epnum;
  760. unsigned long flags;
  761. struct ehci_qh *qh = 0;
  763. qtd = list_entry (qtd_list->next, struct ehci_qtd, qtd_list);
  764. dev = (struct hcd_dev *)urb->dev->hcpriv;
  765. epnum = usb_pipeendpoint (urb->pipe);
  766. if (usb_pipein (urb->pipe))
  767. epnum |= 0x10;
  769. vdbg ("%s: submit_async urb %p len %d ep %d-%s qtd %p [qh %p]",
  770. ehci->hcd.bus_name, urb, urb->transfer_buffer_length,
  771. epnum & 0x0f, (epnum & 0x10) ? "in" : "out",
  772. qtd, dev ? dev->ep [epnum] : (void *)~0);
  774. spin_lock_irqsave (&ehci->lock, flags);
  776. qh = (struct ehci_qh *) dev->ep [epnum];
  777. if (likely (qh != 0)) {
  778. u32 hw_next = QTD_NEXT (qtd->qtd_dma);
  780. /* maybe patch the qh used for set_address */
  781. if (unlikely (epnum == 0
  782. && le32_to_cpu (qh->hw_info1 & 0x7f) == 0))
  783. qh->hw_info1 |= cpu_to_le32 (usb_pipedevice(urb->pipe));
  785. /* is an URB is queued to this qh already? */
  786. if (unlikely (!list_empty (&qh->qtd_list))) {
  787. struct ehci_qtd *last_qtd;
  788. int short_rx = 0;
  790. /* update the last qtd's "next" pointer */
  791. // dbg_qh ("non-empty qh", ehci, qh);
  792. last_qtd = list_entry (qh->qtd_list.prev,
  793. struct ehci_qtd, qtd_list);
  794. last_qtd->hw_next = hw_next;
  796. /* previous urb allows short rx? maybe optimize. */
  797. if (!(last_qtd->urb->transfer_flags & USB_DISABLE_SPD)
  798. && (epnum & 0x10)) {
  799. // only the last QTD for now
  800. last_qtd->hw_alt_next = hw_next;
  801. short_rx = 1;
  802. }
  804. /* Adjust any old copies in qh overlay too.
  805.  * Interrupt code must cope with case of HC having it
  806.  * cached, and clobbering these updates.
  807.  * ... complicates getting rid of extra interrupts!
  808.  */
  809. if (qh->hw_current == cpu_to_le32 (last_qtd->qtd_dma)) {
  810. wmb ();
  811. qh->hw_qtd_next = hw_next;
  812. if (short_rx)
  813. qh->hw_alt_next = hw_next
  814.      | (qh->hw_alt_next & 0x1e);
  815. vdbg ("queue to qh %p, patch", qh);
  816. }
  818. /* no URB queued */
  819. } else {
  820. // dbg_qh ("empty qh", ehci, qh);
  822. /* NOTE: we already canceled any queued URBs
  823.  * when the endpoint halted.
  824.  */
  826. /* usb_clear_halt() means qh data toggle gets reset */
  827. if (usb_pipebulk (urb->pipe)
  828. && unlikely (!usb_gettoggle (urb->dev,
  829. (epnum & 0x0f),
  830. !(epnum & 0x10)))) {
  831. clear_toggle (urb->dev,
  832. epnum & 0x0f, !(epnum & 0x10), qh);
  833. }
  834. qh_update (qh, qtd);
  835. }
  836. list_splice (qtd_list, qh->qtd_list.prev);
  838. } else {
  839. /* can't sleep here, we have ehci->lock... */
  840. qh = ehci_qh_make (ehci, urb, qtd_list, SLAB_ATOMIC);
  841. if (likely (qh != 0)) {
  842. // dbg_qh ("new qh", ehci, qh);
  843. dev->ep [epnum] = qh;
  844. }
  845. }
  847. /* Control/bulk operations through TTs don't need scheduling,
  848.  * the HC and TT handle it when the TT has a buffer ready.
  849.  */
  850. if (likely (qh != 0)) {
  851. urb->hcpriv = qh_get (qh);
  852. if (likely (qh->qh_state == QH_STATE_IDLE))
  853. qh_link_async (ehci, qh_get (qh));
  854. }
  855. spin_unlock_irqrestore (&ehci->lock, flags);
  856. if (unlikely (qh == 0)) {
  857. qtd_list_free (ehci, urb, qtd_list);
  858. return -ENOMEM;
  859. }
  860. return 0;
  861. }
  863. /*-------------------------------------------------------------------------*/
  865. /* the async qh for the qtds being reclaimed are now unlinked from the HC */
  866. /* caller must not own ehci->lock */
  868. static void end_unlink_async (struct ehci_hcd *ehci)
  869. {
  870. struct ehci_qh *qh = ehci->reclaim;
  872. qh->qh_state = QH_STATE_IDLE;
  873. qh->qh_next.qh = 0;
  874. qh_put (ehci, qh); // refcount from reclaim 
  875. ehci->reclaim = 0;
  876. ehci->reclaim_ready = 0;
  878. qh_completions (ehci, qh, 1);
  880. // unlink any urb should now unlink all following urbs, so that
  881. // relinking only happens for urbs before the unlinked ones.
  882. if (!list_empty (&qh->qtd_list)
  883. && HCD_IS_RUNNING (ehci->hcd.state))
  884. qh_link_async (ehci, qh);
  885. else
  886. qh_put (ehci, qh); // refcount from async list
  887. }
  890. /* makes sure the async qh will become idle */
  891. /* caller must own ehci->lock */
  893. static void start_unlink_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
  894. {
  895. int cmd = readl (&ehci->regs->command);
  896. struct ehci_qh *prev;
  898. #ifdef DEBUG
  899. if (ehci->reclaim
  900. || !ehci->async
  901. || qh->qh_state != QH_STATE_LINKED
  902. #ifdef CONFIG_SMP
  903. // this macro lies except on SMP compiles
  904. || !spin_is_locked (&ehci->lock)
  905. #endif
  906. )
  907. BUG ();
  908. #endif
  910. qh->qh_state = QH_STATE_UNLINK;
  911. ehci->reclaim = qh = qh_get (qh);
  913. // dbg_qh ("start unlink", ehci, qh);
  915. /* Remove the last QH (qhead)?  Stop async schedule first. */
  916. if (unlikely (qh == ehci->async && qh->qh_next.qh == qh)) {
  917. /* can't get here without STS_ASS set */
  918. if (ehci->hcd.state != USB_STATE_HALT) {
  919. if (cmd & CMD_PSE)
  920. writel (cmd & ~CMD_ASE, &ehci->regs->command);
  921. else {
  922. ehci_ready (ehci);
  923. while (readl (&ehci->regs->status) & STS_ASS)
  924. udelay (100);
  925. }
  926. }
  927. qh->qh_next.qh = ehci->async = 0;
  929. ehci->reclaim_ready = 1;
  930. tasklet_schedule (&ehci->tasklet);
  931. return;
  932. } 
  934. if (unlikely (ehci->hcd.state == USB_STATE_HALT)) {
  935. ehci->reclaim_ready = 1;
  936. tasklet_schedule (&ehci->tasklet);
  937. return;
  938. }
  940. prev = ehci->async;
  941. while (prev->qh_next.qh != qh && prev->qh_next.qh != ehci->async)
  942. prev = prev->qh_next.qh;
  943. #ifdef DEBUG
  944. if (prev->qh_next.qh != qh)
  945. BUG ();
  946. #endif
  948. if (qh->hw_info1 & __constant_cpu_to_le32 (QH_HEAD)) {
  949. ehci->async = prev;
  950. prev->hw_info1 |= __constant_cpu_to_le32 (QH_HEAD);
  951. }
  952. prev->hw_next = qh->hw_next;
  953. prev->qh_next = qh->qh_next;
  954. wmb ();
  956. ehci->reclaim_ready = 0;
  957. cmd |= CMD_IAAD;
  958. writel (cmd, &ehci->regs->command);
  959. /* posted write need not be known to HC yet ... */
  960. }
  962. /*-------------------------------------------------------------------------*/
  964. static void scan_async (struct ehci_hcd *ehci)
  965. {
  966. struct ehci_qh *qh;
  967. unsigned long flags;
  969. spin_lock_irqsave (&ehci->lock, flags);
  970. rescan:
  971. qh = ehci->async;
  972. if (likely (qh != 0)) {
  973. do {
  974. /* clean any finished work for this qh */
  975. if (!list_empty (&qh->qtd_list)) {
  976. // dbg_qh ("scan_async", ehci, qh);
  977. qh = qh_get (qh);
  978. spin_unlock_irqrestore (&ehci->lock, flags);
  980. /* concurrent unlink could happen here */
  981. qh_completions (ehci, qh, 1);
  983. spin_lock_irqsave (&ehci->lock, flags);
  984. qh_put (ehci, qh);
  985. }
  987. /* unlink idle entries (reduces PCI usage) */
  988. if (list_empty (&qh->qtd_list) && !ehci->reclaim) {
  989. if (qh->qh_next.qh != qh) {
  990. // dbg ("irq/empty");
  991. start_unlink_async (ehci, qh);
  992. } else {
  993. // FIXME:  arrange to stop
  994. // after it's been idle a while.
  995. }
  996. }
  997. qh = qh->qh_next.qh;
  998. if (!qh) /* unlinked? */
  999. goto rescan;
  1000. } while (qh != ehci->async);
  1001. }
  1003. spin_unlock_irqrestore (&ehci->lock, flags);
  1004. }