Lines Matching refs:xfer
85 "struct usbd_xfer *"/*xfer*/);
88 "struct usbd_xfer *"/*xfer*/,
92 "struct usbd_xfer *"/*xfer*/);
104 SDT_PROBE_DEFINE5(usb, device, xfer, create,
105 "struct usbd_xfer *"/*xfer*/,
110 SDT_PROBE_DEFINE1(usb, device, xfer, start, "struct usbd_xfer *"/*xfer*/);
111 SDT_PROBE_DEFINE1(usb, device, xfer, preabort, "struct usbd_xfer *"/*xfer*/);
112 SDT_PROBE_DEFINE1(usb, device, xfer, abort, "struct usbd_xfer *"/*xfer*/);
113 SDT_PROBE_DEFINE1(usb, device, xfer, timeout, "struct usbd_xfer *"/*xfer*/);
114 SDT_PROBE_DEFINE2(usb, device, xfer, done,
115 "struct usbd_xfer *"/*xfer*/,
117 SDT_PROBE_DEFINE1(usb, device, xfer, destroy, "struct usbd_xfer *"/*xfer*/);
199 struct usbd_xfer *xfer;
204 SIMPLEQ_FOREACH(xfer, &pipe->up_queue, ux_next) {
205 USBHIST_LOG(usbdebug, " xfer = %#jx", (uintptr_t)xfer,
304 struct usbd_xfer *xfer;
316 err = usbd_create_xfer(ipipe, len, flags, 0, &xfer);
320 usbd_setup_xfer(xfer, priv, buffer, len, flags, USBD_NO_TIMEOUT, cb);
321 ipipe->up_intrxfer = xfer;
323 err = usbd_transfer(xfer);
335 usbd_destroy_xfer(xfer);
371 usbd_transfer(struct usbd_xfer *xfer)
373 struct usbd_pipe *pipe = xfer->ux_pipe;
378 "xfer = %#jx, flags = %#jx, pipe = %#jx, running = %jd",
379 (uintptr_t)xfer, xfer->ux_flags, (uintptr_t)pipe, pipe->up_running);
380 KASSERT(xfer->ux_status == USBD_NOT_STARTED);
381 SDT_PROBE1(usb, device, xfer, start, xfer);
387 xfer->ux_done = 0;
389 KASSERT(xfer->ux_length == 0 || xfer->ux_buf != NULL);
391 size = xfer->ux_length;
392 flags = xfer->ux_flags;
396 * Use the xfer buffer if none specified in transfer setup.
397 * isoc transfers always use the xfer buffer, i.e.
400 if (xfer->ux_buffer == NULL) {
401 xfer->ux_buffer = xfer->ux_buf;
405 * If not using the xfer buffer copy data to the
406 * xfer buffer for OUT transfers of >0 length
408 if (xfer->ux_buffer != xfer->ux_buf) {
409 KASSERT(xfer->ux_buf);
410 if (!usbd_xfer_isread(xfer)) {
411 memcpy(xfer->ux_buf, xfer->ux_buffer, size);
426 USBHIST_LOG(usbdebug, "<- done xfer %#jx, aborting",
427 (uintptr_t)xfer, 0, 0, 0);
428 SDT_PROBE2(usb, device, xfer, done, xfer, USBD_CANCELLED);
432 /* xfer is not valid after the transfer method unless synchronous */
433 SDT_PROBE2(usb, device, pipe, transfer__start, pipe, xfer);
436 xfer->ux_state = XFER_ONQU;
438 SIMPLEQ_INSERT_TAIL(&pipe->up_queue, xfer, ux_next);
447 err = pipe->up_methods->upm_transfer(xfer);
449 SDT_PROBE3(usb, device, pipe, transfer__done, pipe, xfer, err);
460 USBHIST_LOG(usbdebug, "xfer failed: %jd, reinserting",
464 SDT_PROBE1(usb, device, xfer, preabort, xfer);
466 xfer->ux_state = XFER_BUSY;
476 USBHIST_LOG(usbdebug, "<- done xfer %#jx, not sync (err %jd)",
477 (uintptr_t)xfer, err, 0, 0);
479 "asynchronous xfer %p completed synchronously", xfer);
484 USBHIST_LOG(usbdebug, "<- done xfer %#jx, sync (err %jd)",
485 (uintptr_t)xfer, err, 0, 0);
486 SDT_PROBE2(usb, device, xfer, done, xfer, err);
493 while (!xfer->ux_done) {
496 USBHIST_LOG(usbdebug, "<- sleeping on xfer %#jx",
497 (uintptr_t)xfer, 0, 0, 0);
501 err = cv_wait_sig(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
503 cv_wait(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock);
506 if (!xfer->ux_done) {
507 SDT_PROBE1(usb, device, xfer, abort, xfer);
508 pipe->up_methods->upm_abort(xfer);
513 err = xfer->ux_status;
514 SDT_PROBE2(usb, device, xfer, done, xfer, err);
522 usbd_sync_transfer(struct usbd_xfer *xfer)
524 xfer->ux_flags |= USBD_SYNCHRONOUS;
525 return usbd_transfer(xfer);
530 usbd_sync_transfer_sig(struct usbd_xfer *xfer)
532 xfer->ux_flags |= USBD_SYNCHRONOUS | USBD_SYNCHRONOUS_SIG;
533 return usbd_transfer(xfer);
537 usbd_alloc_buffer(struct usbd_xfer *xfer, uint32_t size)
539 KASSERT(xfer->ux_buf == NULL);
542 xfer->ux_bufsize = 0;
544 struct usbd_bus *bus = xfer->ux_bus;
547 usb_dma_t *dmap = &xfer->ux_dmabuf;
554 xfer->ux_buf = KERNADDR(&xfer
555 xfer->ux_bufsize = size;
557 return xfer->ux_buf;
560 KASSERT(xfer->ux_bus->ub_usedma == false);
561 xfer->ux_buf = kmem_alloc(size, KM_SLEEP);
562 xfer->ux_bufsize = size;
563 return xfer->ux_buf;
567 usbd_free_buffer(struct usbd_xfer *xfer)
569 KASSERT(xfer->ux_buf != NULL);
570 KASSERT(xfer->ux_bufsize != 0);
572 void *buf = xfer->ux_buf;
573 uint32_t size = xfer->ux_bufsize;
575 xfer->ux_buf = NULL;
576 xfer->ux_bufsize = 0;
579 struct usbd_bus *bus = xfer->ux_bus;
582 usb_dma_t *dmap = &xfer->ux_dmabuf;
588 KASSERT(xfer->ux_bus->ub_usedma == false);
594 usbd_get_buffer(struct usbd_xfer *xfer)
596 return xfer->ux_buf;
609 struct usbd_xfer *xfer;
615 xfer = dev->ud_bus->ub_methods->ubm_allocx(dev->ud_bus, nframes);
616 if (xfer == NULL)
618 xfer->ux_bus = dev->ud_bus;
619 callout_init(&xfer->ux_callout, CALLOUT_MPSAFE);
620 callout_setfunc(&xfer->ux_callout, usbd_xfer_timeout, xfer);
621 cv_init(&xfer->ux_cv, "usbxfer");
622 usb_init_task(&xfer->ux_aborttask, usbd_xfer_timeout_task, xfer,
626 USBHIST_CALLARGS(usbdebug, "returns %#jx", (uintptr_t)xfer, 0, 0, 0);
628 return xfer;
632 usbd_free_xfer(struct usbd_xfer *xfer)
635 USBHIST_CALLARGS(usbdebug, "%#jx", (uintptr_t)xfer, 0, 0, 0);
637 if (xfer->ux_buf) {
638 usbd_free_buffer(xfer);
642 mutex_enter(xfer->ux_bus->ub_lock);
643 xfer->ux_timeout_reset = false; /* do not resuscitate */
644 callout_halt(&xfer->ux_callout, xfer->ux_bus->ub_lock);
645 usb_rem_task_wait(xfer->ux_pipe->up_dev, &xfer->ux_aborttask,
646 USB_TASKQ_HC, xfer->ux_bus->ub_lock);
647 mutex_exit(xfer->ux_bus->ub_lock);
649 cv_destroy(&xfer->ux_cv);
650 xfer->ux_bus->ub_methods->ubm_freex(xfer->ux_bus, xfer);
660 struct usbd_xfer *xfer = usbd_alloc_xfer(pipe->up_dev, nframes);
661 if (xfer == NULL)
664 xfer->ux_pipe = pipe;
665 xfer->ux_flags = flags;
666 xfer->ux_nframes = nframes;
667 xfer->ux_methods = pipe->up_methods;
670 buf = usbd_alloc_buffer(xfer, len);
672 usbd_free_xfer(xfer);
677 if (xfer->ux_methods->upm_init) {
678 int err = xfer->ux_methods->upm_init(xfer);
680 usbd_free_xfer(xfer);
685 *xp = xfer;
686 SDT_PROBE5(usb, device, xfer, create,
687 xfer, pipe, len, flags, nframes);
692 usbd_destroy_xfer(struct usbd_xfer *xfer)
695 SDT_PROBE1(usb, device, xfer, destroy, xfer);
696 if (xfer->ux_methods->upm_fini)
697 xfer->ux_methods->upm_fini(xfer);
699 usbd_free_xfer(xfer);
703 usbd_setup_xfer(struct usbd_xfer *xfer, void *priv, void *buffer,
706 KASSERT(xfer->ux_pipe);
708 xfer->ux_priv = priv;
709 xfer->ux_buffer = buffer;
710 xfer->ux_length = length;
711 xfer->ux_actlen = 0;
712 xfer->ux_flags = flags;
713 xfer->ux_timeout = timeout;
714 xfer->ux_status = USBD_NOT_STARTED;
715 xfer->ux_callback = callback;
716 xfer->ux_rqflags &= ~URQ_REQUEST;
717 xfer->ux_nframes = 0;
721 usbd_setup_default_xfer(struct usbd_xfer *xfer, struct usbd_device *dev,
725 KASSERT(xfer->ux_pipe == dev->ud_pipe0);
727 xfer->ux_priv = priv;
728 xfer->ux_buffer = buffer;
729 xfer->ux_length = length;
730 xfer->ux_actlen = 0;
731 xfer->ux_flags = flags;
732 xfer->ux_timeout = timeout;
733 xfer->ux_status = USBD_NOT_STARTED;
734 xfer->ux_callback = callback;
735 xfer->ux_request = *req;
736 xfer->ux_rqflags |= URQ_REQUEST;
737 xfer->ux_nframes = 0;
741 usbd_setup_isoc_xfer(struct usbd_xfer *xfer, void *priv, uint16_t *frlengths,
744 xfer->ux_priv = priv;
745 xfer->ux_buffer = NULL;
746 xfer->ux_length = 0;
747 xfer->ux_actlen = 0;
748 xfer->ux_flags = flags;
749 xfer->ux_timeout = USBD_NO_TIMEOUT;
750 xfer->ux_status = USBD_NOT_STARTED;
751 xfer->ux_callback = callback;
752 xfer->ux_rqflags &= ~URQ_REQUEST;
753 xfer->ux_frlengths = frlengths;
754 xfer->ux_nframes = nframes;
756 for (size_t i = 0; i < xfer->ux_nframes; i++)
757 xfer->ux_length += xfer->ux_frlengths[i];
761 usbd_get_xfer_status(struct usbd_xfer *xfer, void **priv,
765 *priv = xfer->ux_priv;
767 *buffer = xfer->ux_buffer;
769 *count = xfer->ux_actlen;
771 *status = xfer->ux_status;
1032 struct usbd_xfer *xfer;
1046 * stop using the xfer before returning.
1059 while ((xfer = SIMPLEQ_FIRST(&pipe->up_queue)) != NULL) {
1060 USBHIST_LOG(usbdebug, "pipe = %#jx xfer = %#jx "
1061 "(methods = %#jx)", (uintptr_t)pipe, (uintptr_t)xfer,
1063 if (xfer->ux_status == USBD_NOT_STARTED) {
1064 SDT_PROBE1(usb, device, xfer, preabort, xfer);
1066 xfer->ux_state = XFER_BUSY;
1071 SDT_PROBE1(usb, device, xfer, abort, xfer);
1072 pipe->up_methods->upm_abort(xfer);
1073 while (pipe->up_callingxfer == xfer) {
1075 "pipe = %#jx xfer = %#jx",
1076 (uintptr_t)pipe, (uintptr_t)xfer, 0, 0);
1085 * There may be an xfer callback already in progress which was
1092 "pipe = %#jx xfer = %#jx",
1107 usb_transfer_complete(struct usbd_xfer *xfer)
1109 struct usbd_pipe *pipe = xfer->ux_pipe;
1111 int sync = xfer->ux_flags & USBD_SYNCHRONOUS;
1117 USBHIST_CALLARGS(usbdebug, "pipe = %#jx xfer = %#jx status = %jd "
1118 "actlen = %jd", (uintptr_t)pipe, (uintptr_t)xfer, xfer->ux_status,
1119 xfer->ux_actlen);
1122 KASSERTMSG(xfer->ux_state == XFER_ONQU, "xfer %p state is %x", xfer,
1123 xfer->ux_state);
1133 xfer->ux_status == USBD_TIMEOUT &&
1134 !usbd_xfer_isread(xfer)) {
1135 USBHIST_LOG(usbdebug, "Possible output ack miss for xfer %#jx: "
1137 (uintptr_t)xfer, curlwp->l_proc->p_pid, curlwp->l_lid,
1138 xfer->ux_length);
1140 xfer->ux_status = USBD_NORMAL_COMPLETION;
1141 xfer->ux_actlen = xfer->ux_length;
1144 erred = xfer->ux_status == USBD_CANCELLED ||
1145 xfer->ux_status == USBD_TIMEOUT;
1151 "pipe %p is empty, but xfer %p wants to complete", pipe,
1152 xfer);
1153 KASSERTMSG(xfer == SIMPLEQ_FIRST(&pipe->up_queue),
1154 "xfer %p is not start of queue (%p is at start)", xfer,
1158 xfer->ux_state = XFER_BUSY;
1162 USBHIST_LOG(usbdebug, "xfer %#jx: repeat %jd new head = %#jx",
1163 (uintptr_t)xfer, repeat, (uintptr_t)SIMPLEQ_FIRST(&pipe->up_queue),
1170 xfer->ux_done = 1;
1171 if (!xfer->ux_status && xfer->ux_actlen < xfer->ux_length &&
1172 !(xfer->ux_flags & USBD_SHORT_XFER_OK)) {
1174 xfer->ux_actlen, xfer->ux_length, 0, 0);
1175 xfer->ux_status = USBD_SHORT_XFER;
1178 USBHIST_LOG(usbdebug, "xfer %#jx doing done %#jx", (uintptr_t)xfer,
1180 SDT_PROBE2(usb, device, xfer, done, xfer, xfer->ux_status);
1181 pipe->up_methods->upm_done(xfer);
1183 if (xfer->ux_length != 0 && xfer->ux_buffer != xfer->ux_buf) {
1184 KDASSERTMSG(xfer->ux_actlen <= xfer->ux_length,
1185 "actlen %d length %d",xfer->ux_actlen, xfer->ux_length);
1188 if (usbd_xfer_isread(xfer)) {
1189 memcpy(xfer->ux_buffer, xfer->ux_buf, xfer->ux_actlen);
1193 USBHIST_LOG(usbdebug, "xfer %#jx doing callback %#jx status %jd",
1194 (uintptr_t)xfer, (uintptr_t)xfer->ux_callback, xfer->ux_status, 0);
1196 if (xfer->ux_callback) {
1199 pipe->up_callingxfer = xfer;
1205 xfer->ux_callback(xfer, xfer->ux_priv, xfer->ux_status);
1211 xfer);
1218 USBHIST_LOG(usbdebug, "<- done xfer %#jx, wakeup",
1219 (uintptr_t)xfer, 0, 0, 0);
1220 cv_broadcast(&xfer->ux_cv);
1224 xfer->ux_actlen = 0;
1225 xfer->ux_status = USBD_NOT_STARTED;
1239 struct usbd_xfer *xfer;
1253 xfer = SIMPLEQ_FIRST(&pipe->up_queue);
1254 USBHIST_CALLARGS(usbdebug, "pipe = %#jx, xfer = %#jx", (uintptr_t)pipe,
1255 (uintptr_t)xfer, 0, 0);
1256 if (xfer == NULL) {
1259 SDT_PROBE2(usb, device, pipe, start, pipe, xfer);
1260 err = pipe->up_methods->upm_start(xfer);
1293 struct usbd_xfer *xfer;
1307 int error = usbd_create_xfer(dev->ud_pipe0, len, 0, 0, &xfer);
1314 usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data,
1316 KASSERT(xfer->ux_pipe == dev->ud_pipe0);
1317 err = usbd_sync_transfer(xfer);
1319 if (xfer->ux_actlen > xfer->ux_length) {
1321 dev->ud_addr, xfer->ux_request.bmRequestType, 0, 0);
1324 xfer->ux_request.bRequest, UGETW(xfer->ux_request.wValue),
1325 UGETW(xfer->ux_request.wIndex), 0);
1328 UGETW(xfer->ux_request.wLength),
1329 xfer->ux_length, xfer->ux_actlen, 0);
1333 *actlen = xfer->ux_actlen;
1335 usbd_destroy_xfer(xfer);
1338 dev, req, xfer->ux_actlen, flags, timeout, data, err);
1521 * usbd_xfer_trycomplete(xfer)
1523 * Try to claim xfer for completion. Return true if successful,
1524 * false if the xfer has been synchronously aborted or has timed
1528 * xfer->ux_status and calling usb_transfer_complete. To be used
1539 usbd_xfer_trycomplete(struct usbd_xfer *xfer)
1541 struct usbd_bus *bus __diagused = xfer->ux_bus;
1546 USBHIST_CALLARGS(usbdebug, "xfer %#jx status %jd",
1547 (uintptr_t)xfer, xfer->ux_status, 0, 0);
1553 if (xfer->ux_status != USBD_IN_PROGRESS)
1557 * We are completing the xfer. Cancel the timeout if we can,
1561 usbd_xfer_cancel_timeout_async(xfer);
1563 /* Success! Note: Caller must set xfer->ux_status afterwar. */
1568 * usbd_xfer_abort(xfer)
1570 * Try to claim xfer to abort. If successful, mark it completed
1580 usbd_xfer_abort(struct usbd_xfer *xfer)
1582 struct usbd_bus *bus = xfer->ux_bus;
1587 USBHIST_CALLARGS(usbdebug, "xfer %#jx status %jd",
1588 (uintptr_t)xfer, xfer->ux_status, 0, 0);
1592 * completed it, too late. But the xfer cannot be
1596 KASSERT(xfer->ux_status != USBD_CANCELLED);
1597 if (xfer->ux_status != USBD_IN_PROGRESS)
1605 usbd_xfer_cancel_timeout_async(xfer);
1610 * the xfer.
1612 xfer->ux_status = USBD_CANCELLED;
1613 bus->ub_methods->ubm_abortx(xfer);
1614 usb_transfer_complete(xfer);
1618 * usbd_xfer_timeout(xfer)
1621 * for xfer to complete. Since we can't abort the xfer at
1623 * unless the xfer has completed or aborted concurrently -- and if
1624 * the xfer has also been resubmitted, take care of rescheduling
1630 struct usbd_xfer *xfer = cookie;
1631 struct usbd_bus *bus = xfer->ux_bus;
1632 struct usbd_device *dev = xfer->ux_pipe->up_dev;
1638 USBHIST_CALLARGS(usbdebug, "xfer %#jx status %jd",
1639 (uintptr_t)xfer, xfer->ux_status, 0, 0);
1646 if (usbd_xfer_probe_timeout(xfer)) {
1647 USBHIST_LOG(usbdebug, "xfer %#jx schedule timeout task",
1648 (uintptr_t)xfer, 0, 0, 0);
1649 usb_add_task(dev, &xfer->ux_aborttask, USB_TASKQ_HC);
1651 USBHIST_LOG(usbdebug, "xfer %#jx timeout cancelled",
1652 (uintptr_t)xfer, 0, 0, 0);
1661 callout_ack(&xfer->ux_callout);
1668 * usbd_xfer_timeout_task(xfer)
1671 * for xfer to complete. Abort the xfer with USBD_TIMEOUT, unless
1672 * it has completed or aborted concurrently -- and if the xfer has
1678 struct usbd_xfer *xfer = cookie;
1679 struct usbd_bus *bus = xfer->ux_bus;
1685 USBHIST_CALLARGS(usbdebug, "xfer %#jx status %jd",
1686 (uintptr_t)xfer, xfer->ux_status, 0, 0);
1692 * cancelled, or the xfer has already been resubmitted -- then
1695 if (!usbd_xfer_probe_timeout(xfer)) {
1696 USBHIST_LOG(usbdebug, "xfer %#jx timeout cancelled",
1697 (uintptr_t)xfer, 0, 0, 0);
1707 KASSERT(!xfer->ux_timeout_reset);
1708 xfer->ux_timeout_set = false;
1715 KASSERT(xfer->ux_status != USBD_TIMEOUT);
1716 if (xfer->ux_status != USBD_IN_PROGRESS) {
1717 USBHIST_LOG(usbdebug, "xfer %#jx timeout raced",
1718 (uintptr_t)xfer, 0, 0, 0);
1725 * the xfer.
1727 USBHIST_LOG(usbdebug, "xfer %#jx timed out",
1728 (uintptr_t)xfer, 0, 0, 0);
1729 xfer->ux_status = USBD_TIMEOUT;
1730 bus->ub_methods->ubm_abortx(xfer);
1731 usb_transfer_complete(xfer);
1738 * usbd_xfer_probe_timeout(xfer)
1740 * Probe the status of xfer's timeout. Acknowledge and process a
1743 * task or aborting the xfer), false if it must stop here.
1746 usbd_xfer_probe_timeout(struct usbd_xfer *xfer)
1748 struct usbd_bus *bus = xfer->ux_bus;
1752 USBHIST_CALLARGS(usbdebug, "xfer %#jx timeout %jdms"
1754 (uintptr_t)xfer, xfer->ux_timeout,
1755 xfer->ux_timeout_set, xfer->ux_timeout_reset);
1760 KASSERT(xfer->ux_timeout_set);
1766 KASSERT(!callout_pending(&xfer->ux_callout));
1767 KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
1772 USBHIST_LOG(usbdebug, "xfer %#jx bus dying, not rescheduling",
1773 (uintptr_t)xfer, 0, 0, 0);
1774 xfer->ux_timeout_set = false;
1775 xfer->ux_timeout_reset = false;
1777 } else if (xfer->ux_timeout_reset) {
1779 * The xfer completed _and_ got resubmitted while we
1784 xfer->ux_timeout_reset = false;
1785 if (xfer->ux_timeout && !bus->ub_usepolling) {
1786 USBHIST_LOG(usbdebug, "xfer %#jx resubmitted,"
1788 (uintptr_t)xfer, xfer->ux_timeout, 0, 0);
1789 KASSERT(xfer->ux_timeout_set);
1790 callout_schedule(&xfer->ux_callout,
1791 mstohz(xfer->ux_timeout));
1794 USBHIST_LOG(usbdebug, "xfer %#jx resubmitted"
1796 xfer, 0, 0, 0);
1797 xfer->ux_timeout_set = false;
1800 } else if (xfer->ux_status != USBD_IN_PROGRESS) {
1802 * The xfer has completed by hardware completion or by
1807 USBHIST_LOG(usbdebug, "xfer %#jx timeout lost race,"
1809 (uintptr_t)xfer, xfer->ux_status, 0, 0);
1810 xfer->ux_timeout_set = false;
1814 * The xfer has not yet completed, so the timeout is
1817 USBHIST_LOG(usbdebug, "xfer %#jx timing out",
1818 (uintptr_t)xfer, 0, 0, 0);
1823 KASSERT(!xfer->ux_timeout_reset);
1830 KASSERT(xfer->ux_timeout_set || !callout_pending(&xfer->ux_callout));
1844 KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
1852 * usbd_xfer_schedule_timeout(xfer)
1854 * Ensure that xfer has a timeout. If the callout is already
1863 usbd_xfer_schedule_timeout(struct usbd_xfer *xfer)
1865 struct usbd_bus *bus = xfer->ux_bus;
1868 USBHIST_CALLARGS(usbdebug, "xfer %#jx timeout %jdms"
1870 (uintptr_t)xfer, xfer->ux_timeout,
1871 xfer->ux_timeout_set, xfer->ux_timeout_reset);
1874 KASSERTMSG(xfer->ux_status == USBD_IN_PROGRESS, "xfer=%p status=%d",
1875 xfer, xfer->ux_status);
1877 if (xfer->ux_timeout_set) {
1880 * xfer but has not yet noticed that the xfer is done.
1883 xfer->ux_timeout_reset = true;
1884 } else if (xfer->ux_timeout && !bus->ub_usepolling) {
1886 KASSERT(!callout_pending(&xfer->ux_callout));
1887 callout_schedule(&xfer->ux_callout, mstohz(xfer->ux_timeout));
1888 xfer->ux_timeout_set = true;
1895 * usbd_xfer_cancel_timeout_async(xfer)
1897 * Cancel the callout and the task of xfer, which have not yet run
1902 * bus lock. They will see that the xfer is no longer in progress
1903 * and give up, or they will see that the xfer has been
1911 usbd_xfer_cancel_timeout_async(struct usbd_xfer *xfer)
1913 struct usbd_bus *bus __diagused = xfer->ux_bus;
1918 USBHIST_CALLARGS(usbdebug, "xfer %#jx timeout %jdms"
1920 (uintptr_t)xfer, xfer->ux_timeout,
1921 xfer->ux_timeout_set, xfer->ux_timeout_reset);
1928 if (!xfer->ux_timeout_set) {
1929 USBHIST_LOG(usbdebug, "xfer %#jx timer not running",
1930 (uintptr_t)xfer, 0, 0, 0);
1934 xfer->ux_timeout_reset = false;
1935 if (!callout_stop(&xfer->ux_callout)) {
1940 USBHIST_LOG(usbdebug, "xfer %#jx timer stopped",
1941 (uintptr_t)xfer, 0, 0, 0);
1942 xfer->ux_timeout_set = false;
1943 } else if (callout_invoking(&xfer->ux_callout)) {
1953 * xfer and set xfer->ux_timeout_reset = true. In both
1957 USBHIST_LOG(usbdebug, "xfer %#jx timer fired",
1958 (uintptr_t)xfer, 0, 0, 0);
1959 } else if (usb_rem_task(xfer->ux_pipe->up_dev, &xfer->ux_aborttask)) {
1964 * of the xfer must schedule a new timeout.
1968 * xfer->ux_timeout_set is false, or by the callout or
1969 * task itself when xfer->ux_timeout_reset is true.
1971 USBHIST_LOG(usbdebug, "xfer %#jx task fired",
1972 (uintptr_t)xfer, 0, 0, 0);
1973 xfer->ux_timeout_set = false;
1975 USBHIST_LOG(usbdebug, "xfer %#jx task stopped",
1976 (uintptr_t)xfer, 0, 0, 0);
1984 KASSERT(!callout_pending(&xfer->ux_callout));
1985 KASSERT(!usb_task_pending(xfer->ux_pipe->up_dev, &xfer->ux_aborttask));
Indexes created Tue Oct 21 16:10:11 GMT 2025