Lines Matching refs:xfer
153 usb_request_callback(struct usb_xfer *xfer, usb_error_t error)
155 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
156 usb_handle_request_callback(xfer, error);
158 usbd_do_request_callback(xfer, error);
168 usbd_update_max_frame_size(struct usb_xfer *xfer)
174 xfer->max_frame_size = xfer->max_packet_size * xfer->max_packet_count;
466 struct usb_xfer *xfer = parm->curr_xfer;
488 edesc = xfer->endpoint->edesc;
489 ecomp = xfer->endpoint->ecomp;
493 xfer->flags = setup->flags;
494 xfer->nframes = setup->frames;
495 xfer->timeout = setup->timeout;
496 xfer->callback = setup->callback;
497 xfer->interval = setup->interval;
498 xfer->endpointno = edesc->bEndpointAddress;
499 xfer->max_packet_size = UGETW(edesc->wMaxPacketSize);
500 xfer->max_packet_count = 1;
502 xfer->flags_int.usb_mode = parm->udev->flags.usb_mode;
511 xfer->max_packet_count +=
512 (xfer->max_packet_size >> 11) & 3;
515 if (xfer->max_packet_count > 3)
516 xfer->max_packet_count = 3;
521 xfer->max_packet_size &= 0x7FF;
524 xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3;
527 xfer->max_packet_count += ecomp->bMaxBurst;
529 if ((xfer->max_packet_count == 0) ||
530 (xfer->max_packet_count > 16))
531 xfer->max_packet_count = 16;
535 xfer->max_packet_count = 1;
546 xfer->max_packet_count *= mult;
552 xfer->max_packet_size &= 0x7FF;
559 if (xfer->max_packet_count > parm->hc_max_packet_count) {
560 xfer->max_packet_count = parm->hc_max_packet_count;
565 maxp_old = xfer->max_packet_size;
569 if ((xfer->max_packet_size > parm->hc_max_packet_size) ||
570 (xfer->max_packet_size == 0)) {
571 xfer->max_packet_size = parm->hc_max_packet_size;
579 if (xfer->max_packet_size < std_size.range.min) {
580 xfer->max_packet_size = std_size.range.min;
582 if (xfer->max_packet_size > std_size.range.max) {
583 xfer->max_packet_size = std_size.range.max;
587 if (xfer->max_packet_size >= std_size.fixed[3]) {
588 xfer->max_packet_size = std_size.fixed[3];
589 } else if (xfer->max_packet_size >= std_size.fixed[2]) {
590 xfer->max_packet_size = std_size.fixed[2];
591 } else if (xfer->max_packet_size >= std_size.fixed[1]) {
592 xfer->max_packet_size = std_size.fixed[1];
595 xfer->max_packet_size = std_size.fixed[0];
603 if (maxp_old != xfer->max_packet_size)
604 xfer->flags_int.maxp_was_clamped = 1;
608 usbd_update_max_frame_size(xfer);
616 xfer->interval = 0; /* not used, must be zero */
617 xfer->flags_int.isochronous_xfr = 1; /* set flag */
619 if (xfer->timeout == 0) {
624 xfer->timeout = 1000 / 4;
630 xfer->fps_shift = 0;
634 xfer->fps_shift = edesc->bInterval;
635 if (xfer->fps_shift > 0)
636 xfer->fps_shift--;
637 if (xfer->fps_shift > 3)
638 xfer->fps_shift = 3;
639 if (xfer->flags.pre_scale_frames != 0)
640 xfer->nframes <<= (3 - xfer->fps_shift);
644 if (xfer->nframes > frame_limit) {
652 if (xfer->nframes == 0) {
669 if (xfer->interval == 0) {
671 xfer->interval = edesc->bInterval;
679 if (xfer->interval < 4)
680 xfer->interval = 1;
681 else if (xfer->interval > 16)
682 xfer->interval = (1 << (16 - 4));
684 xfer->interval =
685 (1 << (xfer->interval - 4));
690 if (xfer->interval == 0) {
695 xfer->interval = 1;
698 xfer->fps_shift = 0;
701 while ((temp != 0) && (temp < xfer->interval)) {
702 xfer->fps_shift++;
711 xfer->fps_shift += 3;
723 if ((xfer->max_frame_size == 0) ||
724 (xfer->max_packet_size == 0)) {
733 xfer->max_packet_size = MIN_PKT;
734 xfer->max_packet_count = 1;
736 usbd_update_max_frame_size(xfer);
754 parm->bufsize = xfer->max_frame_size;
757 parm->bufsize *= xfer->nframes;
765 if (xfer->flags.proxy_buffer) {
769 parm->bufsize += (xfer->max_frame_size - 1);
771 if (parm->bufsize < xfer->max_frame_size) {
778 parm->bufsize -= (parm->bufsize % xfer->max_frame_size);
786 xfer->max_data_length = parm->bufsize;
791 n_frlengths = xfer->nframes;
796 xfer->flags_int.control_xfr = 1;
797 if (xfer->nframes == 0) {
803 xfer->nframes = 1;
805 xfer->nframes = 2;
809 if (xfer->nframes == 0) {
810 xfer->nframes = 1;
814 n_frlengths = xfer->nframes;
815 n_frbuffers = xfer->nframes;
825 if (xfer->max_data_length < REQ_SIZE) {
830 xfer->max_data_length -= REQ_SIZE;
837 xfer->frlengths = parm->xfer_length_ptr;
841 xfer->frbuffers = parm->xfer_page_cache_ptr;
845 xfer->max_frame_count = xfer->nframes;
852 if (!xfer->flags.ext_buffer) {
864 xfer->local_buffer = page_info.buffer;
866 usbd_xfer_set_frame_offset(xfer, 0, 0);
869 usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
877 xfer->local_buffer =
880 usbd_xfer_set_frame_offset(xfer, 0, 0);
883 usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
900 if (xfer->flags_int.bdma_enable) {
923 xfer->dma_page_ptr = parm->dma_page_ptr;
930 xfer->max_data_length = 0;
934 xfer->max_hc_frame_size =
936 (parm->hc_max_frame_size % xfer->max_frame_size));
938 if (xfer->max_hc_frame_size == 0) {
947 xfer->frbuffers[x].tag_parent =
948 &xfer->xroot->dma_parent_tag;
950 if (xfer->flags_int.bdma_enable &&
954 xfer->frbuffers + x,
968 xfer->max_hc_frame_size = 1;
969 xfer->max_frame_size = 1;
970 xfer->max_packet_size = 1;
971 xfer->max_data_length = 0;
972 xfer->nframes = 0;
973 xfer->max_frame_count = 0;
1014 struct usb_xfer *xfer;
1190 xfer = USB_ADD_BYTES(buf, parm->size[0]);
1191 xfer->address = udev->address;
1192 xfer->priv_sc = priv_sc;
1193 xfer->xroot = info;
1195 usb_callout_init_mtx(&xfer->timeout_handle,
1199 * Setup a dummy xfer, hence we are
1201 * structure pointed to by "xfer"
1205 xfer = &udev->scratch.xfer_setup[0].dummy;
1206 memset(xfer, 0, sizeof(*xfer));
1211 xfer->endpoint = ep;
1214 xfer->stream_id = setup->stream_id;
1216 parm->size[0] += sizeof(xfer[0]);
1217 parm->methods = xfer->endpoint->methods;
1218 parm->curr_xfer = xfer;
1241 if (xfer->endpoint->refcount_alloc >= USB_EP_REF_MAX)
1244 xfer->endpoint->refcount_alloc++;
1246 if (xfer->endpoint->refcount_alloc == 0)
1261 ppxfer[n] = xfer;
1422 /* free DMA maps in all "xfer->frbuffers" */
1452 struct usb_xfer *xfer;
1460 xfer = pxfer[n_setup];
1462 if (xfer == NULL)
1465 info = xfer->xroot;
1467 USB_XFER_LOCK(xfer);
1489 USB_XFER_UNLOCK(xfer);
1491 usbd_transfer_drain(xfer);
1494 if (xfer->flags_int.bdma_enable)
1502 xfer->endpoint->refcount_alloc--;
1505 usb_callout_drain(&xfer->timeout_handle);
1535 usbd_control_transfer_init(struct usb_xfer *xfer)
1541 usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
1545 xfer->flags_int.control_rem = UGETW(req.wLength);
1549 xfer->endpointno &= ~(UE_DIR_IN | UE_DIR_OUT);
1550 xfer->endpointno |=
1562 usbd_control_transfer_did_data(struct usb_xfer *xfer)
1567 if (xfer->flags_int.control_hdr != 0)
1571 usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
1574 return (xfer->flags_int.control_rem != UGETW(req.wLength));
1589 usbd_setup_ctrl_transfer(struct usb_xfer *xfer)
1594 if (xfer->flags.stall_pipe && xfer->flags_int.control_act) {
1596 xfer->flags_int.control_stall = 1;
1597 xfer->flags_int.control_act = 0;
1600 xfer->flags_int.control_stall = 0;
1604 if (xfer->nframes > 2) {
1612 (unsigned int)xfer->nframes);
1620 if (xfer->flags_int.control_act) {
1622 if (xfer->flags_int.control_hdr) {
1626 xfer->flags_int.control_hdr = 0;
1629 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
1630 usbd_control_transfer_init(xfer);
1635 len = xfer->sumlen;
1641 if (xfer->frlengths[0] != sizeof(struct usb_device_request)) {
1643 xfer->frlengths[0], sizeof(struct
1648 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
1651 if (xfer->nframes != 1) {
1665 xfer->flags_int.control_rem = 0xFFFF;
1670 usbd_control_transfer_init(xfer);
1675 xfer->flags_int.control_hdr = 1;
1679 len = (xfer->sumlen - sizeof(struct usb_device_request));
1684 xfer->flags_int.control_did_data =
1685 usbd_control_transfer_did_data(xfer);
1689 if (len > xfer->flags_int.control_rem) {
1692 xfer->flags_int.control_rem);
1697 if (xfer->flags.force_short_xfer) {
1698 xfer->flags_int.control_rem = 0;
1700 if ((len != xfer->max_data_length) &&
1701 (len != xfer->flags_int.control_rem) &&
1702 (xfer->nframes != 1)) {
1707 xfer->flags_int.control_rem -= len;
1712 if ((xfer->flags_int.control_rem > 0) ||
1713 (xfer->flags.manual_status)) {
1715 xfer->flags_int.control_act = 1;
1718 if ((!xfer->flags_int.control_hdr) &&
1719 (xfer->nframes == 1)) {
1729 xfer->flags_int.control_act = 0;
1743 usbd_transfer_submit(struct usb_xfer *xfer)
1749 info = xfer->xroot;
1752 DPRINTF("xfer=%p, endpoint=%p, nframes=%d, dir=%s\n",
1753 xfer, xfer->endpoint, xfer->nframes, USB_GET_DATA_ISREAD(xfer) ?
1760 usb_dump_endpoint(xfer->endpoint);
1766 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1770 if (!xfer->flags_int.open) {
1771 xfer->flags_int.open = 1;
1776 (xfer->endpoint->methods->open) (xfer);
1780 xfer->flags_int.transferring = 1;
1784 usbd_transfer_power_ref(xfer, 1);
1790 if (xfer->wait_queue) {
1792 usbd_transfer_dequeue(xfer);
1796 xfer->flags_int.did_dma_delay = 0;
1799 xfer->flags_int.did_close = 0;
1803 xfer->flags_int.bdma_setup = 0;
1806 xfer->flags_int.can_cancel_immed = 0;
1809 xfer->sumlen = 0;
1810 xfer->actlen = 0;
1811 xfer->aframes = 0;
1814 xfer->error = 0;
1823 usbd_transfer_done(xfer, USB_ERR_CANCELLED);
1829 if (xfer->nframes == 0) {
1830 if (xfer->flags.stall_pipe) {
1835 DPRINTF("xfer=%p nframes=0: stall "
1836 "or clear stall!\n", xfer);
1838 xfer->flags_int.can_cancel_immed = 1;
1840 usb_command_wrapper(&xfer->endpoint->
1841 endpoint_q[xfer->stream_id], xfer);
1846 usbd_transfer_done(xfer, USB_ERR_INVAL);
1852 for (x = 0; x != xfer->nframes; x++) {
1854 xfer->frlengths[x + xfer->max_frame_count] = xfer->frlengths[x];
1856 xfer->sumlen += xfer->frlengths[x];
1857 if (xfer->sumlen < xfer->frlengths[x]) {
1860 usbd_transfer_done(xfer, USB_ERR_INVAL);
1868 xfer->flags_int.short_xfer_ok = 0;
1869 xfer->flags_int.short_frames_ok = 0;
1873 if (xfer->flags_int.control_xfr) {
1875 if (usbd_setup_ctrl_transfer(xfer)) {
1877 usbd_transfer_done(xfer, USB_ERR_STALLED);
1886 if (USB_GET_DATA_ISREAD(xfer)) {
1888 if (xfer->flags.short_frames_ok) {
1889 xfer->flags_int.short_xfer_ok = 1;
1890 xfer->flags_int.short_frames_ok = 1;
1891 } else if (xfer->flags.short_xfer_ok) {
1892 xfer->flags_int.short_xfer_ok = 1;
1895 if (xfer->flags_int.control_xfr) {
1909 xfer->flags_int.short_frames_ok = 1;
1918 if (xfer->flags_int.bdma_enable) {
1920 usb_command_wrapper(&xfer->xroot->dma_q, xfer);
1928 usbd_pipe_enter(xfer);
1935 usbd_pipe_enter(struct usb_xfer *xfer)
1939 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1941 USB_BUS_LOCK(xfer->xroot->bus);
1943 ep = xfer->endpoint;
1948 xfer->flags_int.can_cancel_immed = 1;
1951 (ep->methods->enter) (xfer);
1954 if (xfer->error) {
1956 usbd_transfer_done(xfer, 0);
1957 USB_BUS_UNLOCK(xfer->xroot->bus);
1962 usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], xfer);
1963 USB_BUS_UNLOCK(xfer->xroot->bus);
1974 usbd_transfer_start(struct usb_xfer *xfer)
1976 if (xfer == NULL) {
1980 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1984 if (!xfer->flags_int.started) {
1986 USB_BUS_LOCK(xfer->xroot->bus);
1987 xfer->flags_int.started = 1;
1988 USB_BUS_UNLOCK(xfer->xroot->bus);
1992 if (xfer->flags_int.transferring) {
1995 USB_BUS_LOCK(xfer->xroot->bus);
1997 usbd_callback_ss_done_defer(xfer);
1998 USB_BUS_UNLOCK(xfer->xroot->bus);
2010 usbd_transfer_stop(struct usb_xfer *xfer)
2014 if (xfer == NULL) {
2018 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2022 if (!xfer->flags_int.open) {
2023 if (xfer->flags_int.started) {
2026 USB_BUS_LOCK(xfer->xroot->bus);
2027 xfer->flags_int.started = 0;
2028 USB_BUS_UNLOCK(xfer->xroot->bus);
2034 USB_BUS_LOCK(xfer->xroot->bus);
2036 xfer->error = USB_ERR_CANCELLED;
2042 xfer->flags_int.open = 0;
2043 xfer->flags_int.started = 0;
2048 if (xfer->flags_int.transferring) {
2049 if (xfer->flags_int.can_cancel_immed &&
2050 (!xfer->flags_int.did_close)) {
2056 (xfer->endpoint->methods->close) (xfer);
2058 xfer->flags_int.did_close = 1;
2066 (xfer->endpoint->methods->close) (xfer);
2077 ep = xfer->endpoint;
2083 if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
2085 &ep->endpoint_q[xfer->stream_id], NULL);
2089 USB_BUS_UNLOCK(xfer->xroot->bus);
2102 usbd_transfer_pending(struct usb_xfer *xfer)
2107 if (xfer == NULL) {
2111 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2113 if (xfer->flags_int.transferring) {
2117 USB_BUS_LOCK(xfer->xroot->bus);
2118 if (xfer->wait_queue) {
2120 USB_BUS_UNLOCK(xfer->xroot->bus);
2123 info = xfer->xroot;
2126 if (pq->curr == xfer) {
2128 USB_BUS_UNLOCK(xfer->xroot->bus);
2132 USB_BUS_UNLOCK(xfer->xroot->bus);
2145 usbd_transfer_drain(struct usb_xfer *xfer)
2150 if (xfer == NULL) {
2154 if (xfer->xroot->xfer_mtx != &Giant) {
2155 USB_XFER_LOCK_ASSERT(xfer, MA_NOTOWNED);
2157 USB_XFER_LOCK(xfer);
2159 usbd_transfer_stop(xfer);
2161 while (usbd_transfer_pending(xfer) ||
2162 xfer->flags_int.doing_callback) {
2171 xfer->flags_int.draining = 1;
2177 cv_wait(&xfer->xroot->cv_drain, xfer->xroot->xfer_mtx);
2179 USB_XFER_UNLOCK(xfer);
2183 usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
2185 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2187 return (&xfer->frbuffers[frindex]);
2191 usbd_xfer_get_frame_buffer(struct usb_xfer *xfer, usb_frcount_t frindex)
2195 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2197 usbd_get_page(&xfer->frbuffers[frindex], 0, &page_info);
2213 usbd_xfer_get_fps_shift(struct usb_xfer *xfer)
2215 return (xfer->fps_shift);
2219 usbd_xfer_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex)
2221 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2223 return (xfer->frlengths[frindex]);
2235 usbd_xfer_set_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
2238 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2241 xfer->frbuffers[frindex].buffer = ptr;
2242 usbd_xfer_set_frame_len(xfer, frindex, len);
2246 usbd_xfer_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
2249 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2252 *ptr = xfer->frbuffers[frindex].buffer;
2254 *len = xfer->frlengths[frindex];
2266 usbd_xfer_old_frame_length(struct usb_xfer *xfer, usb_frcount_t frindex)
2268 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2270 return (xfer->frlengths[frindex + xfer->max_frame_count]);
2274 usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes,
2278 *actlen = xfer->actlen;
2280 *sumlen = xfer->sumlen;
2282 *aframes = xfer->aframes;
2284 *nframes = xfer->nframes;
2294 usbd_xfer_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
2297 KASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "
2299 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2302 xfer->frbuffers[frindex].buffer =
2303 USB_ADD_BYTES(xfer->local_buffer, offset);
2307 usbd_xfer_set_interval(struct usb_xfer *xfer, int i)
2309 xfer->interval = i;
2313 usbd_xfer_set_timeout(struct usb_xfer *xfer, int t)
2315 xfer->timeout = t;
2319 usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
2321 xfer->nframes = n;
2325 usbd_xfer_max_frames(struct usb_xfer *xfer)
2327 return (xfer->max_frame_count);
2331 usbd_xfer_max_len(struct usb_xfer *xfer)
2333 return (xfer->max_data_length);
2337 usbd_xfer_max_framelen(struct usb_xfer *xfer)
2339 return (xfer->max_frame_size);
2343 usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex,
2346 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2348 xfer->frlengths[frindex] = len;
2386 usbd_callback_ss_done_defer(struct usb_xfer *xfer)
2388 struct usb_xfer_root *info = xfer->xroot;
2391 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2393 if (pq->curr != xfer) {
2394 usbd_transfer_enqueue(pq, xfer);
2424 struct usb_xfer *xfer = pq->curr;
2425 struct usb_xfer_root *info = xfer->xroot;
2463 xfer->flags_int.doing_callback = 1;
2469 if (!xfer->flags_int.transferring) {
2470 xfer->usb_state = USB_ST_SETUP;
2471 if (!xfer->flags_int.started) {
2478 if (usbd_callback_wrapper_sub(xfer)) {
2485 usbd_transfer_power_ref(xfer, -1);
2487 xfer->flags_int.transferring = 0;
2489 if (xfer->error) {
2490 xfer->usb_state = USB_ST_ERROR;
2493 xfer->usb_state = USB_ST_TRANSFERRED;
2496 if (xfer->flags_int.bdma_enable &&
2497 (!xfer->flags_int.bdma_no_post_sync)) {
2498 usb_bdma_post_sync(xfer);
2505 if (xfer->usb_state != USB_ST_SETUP) {
2507 usbpf_xfertap(xfer, USBPF_XFERTAP_DONE);
2512 (xfer->callback) (xfer, xfer->error);
2521 if ((!xfer->flags_int.open) &&
2522 (xfer->flags_int.started) &&
2523 (xfer->usb_state == USB_ST_ERROR)) {
2525 xfer->flags_int.doing_callback = 0;
2527 usb_command_wrapper(&info->done_q, xfer);
2533 xfer->flags_int.doing_callback = 0;
2538 if (xfer->flags_int.draining &&
2539 (!xfer->flags_int.transferring)) {
2541 xfer->flags_int.draining = 0;
2559 usb_dma_delay_done_cb(struct usb_xfer *xfer)
2561 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2563 DPRINTFN(3, "Completed %p\n", xfer);
2566 usbd_transfer_done(xfer, 0);
2578 usbd_transfer_dequeue(struct usb_xfer *xfer)
2582 pq = xfer->wait_queue;
2584 TAILQ_REMOVE(&pq->head, xfer, wait_entry);
2585 xfer->wait_queue = NULL;
2598 usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
2604 if (xfer->wait_queue == NULL) {
2605 xfer->wait_queue = pq;
2606 TAILQ_INSERT_TAIL(&pq->head, xfer, wait_entry);
2622 usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error)
2624 struct usb_xfer_root *info = xfer->xroot;
2634 if (!xfer->flags_int.transferring) {
2637 xfer->flags_int.control_act = 0;
2641 if (xfer->error == USB_ERR_NORMAL_COMPLETION)
2642 xfer->error = error;
2645 usb_callout_stop(&xfer->timeout_handle);
2652 usbd_transfer_dequeue(xfer);
2664 if (pq->curr == xfer) {
2671 if (xfer->error == USB_ERR_CANCELLED) {
2673 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2674 } else if (xfer->error != USB_ERR_NORMAL_COMPLETION) {
2676 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2679 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2683 usbd_callback_ss_done_defer(xfer);
2690 * "xfer->interval" is greater than zero, and and the endpoint type is
2696 struct usb_xfer *xfer = arg;
2697 struct usb_endpoint *ep = xfer->endpoint;
2699 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2704 usbpf_xfertap(xfer, USBPF_XFERTAP_SUBMIT);
2708 xfer->flags_int.can_cancel_immed = 1;
2711 if (xfer->error == 0)
2712 (ep->methods->start) (xfer);
2715 if (xfer->error) {
2717 usbd_transfer_done(xfer, 0);
2728 usbd_xfer_set_stall(struct usb_xfer *xfer)
2730 if (xfer == NULL) {
2734 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2737 USB_BUS_LOCK(xfer->xroot->bus);
2738 xfer->flags.stall_pipe = 1;
2739 USB_BUS_UNLOCK(xfer->xroot->bus);
2743 usbd_xfer_is_stalled(struct usb_xfer *xfer)
2745 return (xfer->endpoint->is_stalled);
2755 usbd_transfer_clear_stall(struct usb_xfer *xfer)
2757 if (xfer == NULL) {
2761 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2764 USB_BUS_LOCK(xfer->xroot->bus);
2766 xfer->flags.stall_pipe = 0;
2768 USB_BUS_UNLOCK(xfer->xroot->bus);
2780 struct usb_xfer *xfer;
2783 xfer = pq->curr;
2784 ep = xfer->endpoint;
2786 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2797 if (xfer->flags.stall_pipe) {
2802 xfer->flags.stall_pipe = 0;
2805 info = xfer->xroot;
2857 if (xfer->nframes == 0) {
2859 xfer->aframes = 0;
2860 usbd_transfer_done(xfer, 0);
2874 if (xfer->interval > 0) {
2878 usbd_transfer_timeout_ms(xfer,
2880 xfer->interval);
2887 usbpf_xfertap(xfer, USBPF_XFERTAP_SUBMIT);
2890 xfer->flags_int.can_cancel_immed = 1;
2893 if (xfer->error == 0)
2894 (ep->methods->start) (xfer);
2897 if (xfer->error) {
2899 usbd_transfer_done(xfer, 0);
2911 usbd_transfer_timeout_ms(struct usb_xfer *xfer,
2914 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2917 usb_callout_reset(&xfer->timeout_handle,
2918 USB_MS_TO_TICKS(ms) + USB_CALLOUT_ZERO_TICKS, cb, xfer);
2939 usbd_callback_wrapper_sub(struct usb_xfer *xfer)
2945 bus = xfer->xroot->bus;
2947 if ((!xfer->flags_int.open) &&
2948 (!xfer->flags_int.did_close)) {
2951 (xfer->endpoint->methods->close) (xfer);
2954 xfer->flags_int.did_close = 1;
2961 if (xfer->error != 0 && !xfer->flags_int.did_dma_delay &&
2962 (xfer->error == USB_ERR_CANCELLED ||
2963 xfer->error == USB_ERR_TIMEOUT ||
2969 xfer->flags_int.did_dma_delay = 1;
2972 xfer->flags_int.can_cancel_immed = 0;
2974 temp = usbd_get_dma_delay(xfer->xroot->udev);
2977 "on %p\n", temp, xfer);
2988 (bus->methods->start_dma_delay) (xfer);
2990 usbd_transfer_timeout_ms(xfer,
2999 if (xfer->aframes > xfer->nframes) {
3000 if (xfer->error == 0) {
3003 __FUNCTION__, xfer->aframes, xfer->nframes);
3006 xfer->aframes = xfer->nframes;
3010 xfer->actlen = 0;
3012 for (x = 0; x != xfer->aframes; x++) {
3013 xfer->actlen += xfer->frlengths[x];
3019 * of frames transferred, "xfer->aframes":
3021 for (; x < xfer->nframes; x++) {
3022 usbd_xfer_set_frame_len(xfer, x, 0);
3026 if (xfer->actlen > xfer->sumlen) {
3027 if (xfer->error == 0) {
3030 __FUNCTION__, xfer->actlen, xfer->sumlen);
3033 xfer->actlen = xfer->sumlen;
3036 DPRINTFN(1, "xfer=%p endpoint=%p sts=%d alen=%d, slen=%d, afrm=%d, nfrm=%d\n",
3037 xfer, xfer->endpoint, xfer->error, xfer->actlen, xfer->sumlen,
3038 xfer->aframes, xfer->nframes);
3040 if (xfer->error) {
3042 xfer->flags_int.control_act = 0;
3045 switch (xfer->error) {
3055 uhub_tt_buffer_reset_async_locked(xfer->xroot->udev, xfer->endpoint);
3061 if ((xfer->error != USB_ERR_CANCELLED) &&
3062 (xfer->flags.pipe_bof)) {
3063 DPRINTFN(2, "xfer=%p: Block On Failure "
3064 "on endpoint=%p\n", xfer, xfer->endpoint);
3069 if (xfer->actlen < xfer->sumlen) {
3072 xfer->flags_int.control_act = 0;
3074 if (!xfer->flags_int.short_xfer_ok) {
3075 xfer->error = USB_ERR_SHORT_XFER;
3076 if (xfer->flags.pipe_bof) {
3077 DPRINTFN(2, "xfer=%p: Block On Failure on "
3079 xfer, xfer->endpoint);
3088 if (xfer->flags_int.control_act) {
3089 DPRINTFN(5, "xfer=%p: Control transfer "
3090 "active on endpoint=%p\n", xfer, xfer->endpoint);
3096 ep = xfer->endpoint;
3103 if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
3104 usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], NULL);
3106 if (ep->endpoint_q[xfer->stream_id].curr != NULL ||
3107 TAILQ_FIRST(&ep->endpoint_q[xfer->stream_id].head) != NULL) {
3112 xfer->endpoint->is_synced = 0;
3127 usb_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
3129 if (xfer) {
3134 if (pq->curr != xfer) {
3135 usbd_transfer_enqueue(pq, xfer);
3158 xfer = TAILQ_FIRST(&pq->head);
3159 if (xfer) {
3160 TAILQ_REMOVE(&pq->head, xfer,
3162 xfer->wait_queue = NULL;
3163 pq->curr = xfer;
3198 struct usb_xfer *xfer;
3207 xfer = udev->ctrl_xfer[0];
3208 if (xfer) {
3209 USB_XFER_LOCK(xfer);
3211 ((xfer->address == udev->address) &&
3217 * NOTE: checking "xfer->address" and
3221 usbd_transfer_start(xfer);
3224 USB_XFER_UNLOCK(xfer);
3410 struct usb_xfer *xfer;
3420 xfer = ppxfer[n];
3421 if (xfer == NULL)
3423 xroot = xfer->xroot;
3566 usbd_xfer_softc(struct usb_xfer *xfer)
3568 return (xfer->priv_sc);
3572 usbd_xfer_get_priv(struct usb_xfer *xfer)
3574 return (xfer->priv_fifo);
3578 usbd_xfer_set_priv(struct usb_xfer *xfer, void *ptr)
3580 xfer->priv_fifo = ptr;
3584 usbd_xfer_state(struct usb_xfer *xfer)
3586 return (xfer->usb_state);
3590 usbd_xfer_set_flag(struct usb_xfer *xfer, int flag)
3594 xfer->flags.force_short_xfer = 1;
3597 xfer->flags.short_xfer_ok = 1;
3600 xfer->flags.short_frames_ok = 1;
3603 xfer->flags.manual_status = 1;
3609 usbd_xfer_clr_flag(struct usb_xfer *xfer, int flag)
3613 xfer->flags.force_short_xfer = 0;
3616 xfer->flags.short_xfer_ok = 0;
3619 xfer->flags.short_frames_ok = 0;
3622 xfer->flags.manual_status = 0;
3633 usbd_xfer_get_timestamp(struct usb_xfer *xfer)
3635 return (xfer->isoc_time_complete);
3643 usbd_xfer_maxp_was_clamped(struct usb_xfer *xfer)
3645 return (xfer->flags_int.maxp_was_clamped);