Lines Matching defs:xfer
117 usb_request_callback(struct usb_xfer *xfer, usb_error_t error)
119 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
120 usb_handle_request_callback(xfer, error);
122 usbd_do_request_callback(xfer, error);
132 usbd_update_max_frame_size(struct usb_xfer *xfer)
138 xfer->max_frame_size = xfer->max_packet_size * xfer->max_packet_count;
330 struct usb_xfer *xfer = parm->curr_xfer;
352 edesc = xfer->endpoint->edesc;
353 ecomp = xfer->endpoint->ecomp;
357 xfer->flags = setup->flags;
358 xfer->nframes = setup->frames;
359 xfer->timeout = setup->timeout;
360 xfer->callback = setup->callback;
361 xfer->interval = setup->interval;
362 xfer->endpointno = edesc->bEndpointAddress;
363 xfer->max_packet_size = UGETW(edesc->wMaxPacketSize);
364 xfer->max_packet_count = 1;
366 xfer->flags_int.usb_mode = parm->udev->flags.usb_mode;
375 xfer->max_packet_count +=
376 (xfer->max_packet_size >> 11) & 3;
379 if (xfer->max_packet_count > 3)
380 xfer->max_packet_count = 3;
385 xfer->max_packet_size &= 0x7FF;
388 xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3;
391 xfer->max_packet_count += ecomp->bMaxBurst;
393 if ((xfer->max_packet_count == 0) ||
394 (xfer->max_packet_count > 16))
395 xfer->max_packet_count = 16;
399 xfer->max_packet_count = 1;
410 xfer->max_packet_count *= mult;
416 xfer->max_packet_size &= 0x7FF;
423 if (xfer->max_packet_count > parm->hc_max_packet_count) {
424 xfer->max_packet_count = parm->hc_max_packet_count;
429 maxp_old = xfer->max_packet_size;
433 if ((xfer->max_packet_size > parm->hc_max_packet_size) ||
434 (xfer->max_packet_size == 0)) {
435 xfer->max_packet_size = parm->hc_max_packet_size;
442 if (xfer->max_packet_size < std_size.range.min) {
443 xfer->max_packet_size = std_size.range.min;
445 if (xfer->max_packet_size > std_size.range.max) {
446 xfer->max_packet_size = std_size.range.max;
449 if (xfer->max_packet_size >= std_size.fixed[3]) {
450 xfer->max_packet_size = std_size.fixed[3];
451 } else if (xfer->max_packet_size >= std_size.fixed[2]) {
452 xfer->max_packet_size = std_size.fixed[2];
453 } else if (xfer->max_packet_size >= std_size.fixed[1]) {
454 xfer->max_packet_size = std_size.fixed[1];
457 xfer->max_packet_size = std_size.fixed[0];
465 if (maxp_old != xfer->max_packet_size)
466 xfer->flags_int.maxp_was_clamped = 1;
470 usbd_update_max_frame_size(xfer);
477 xfer->interval = 0; /* not used, must be zero */
478 xfer->flags_int.isochronous_xfr = 1; /* set flag */
480 if (xfer->timeout == 0) {
485 xfer->timeout = 1000 / 4;
491 xfer->fps_shift = 0;
495 xfer->fps_shift = edesc->bInterval;
496 if (xfer->fps_shift > 0)
497 xfer->fps_shift--;
498 if (xfer->fps_shift > 3)
499 xfer->fps_shift = 3;
500 if (xfer->flags.pre_scale_frames != 0)
501 xfer->nframes <<= (3 - xfer->fps_shift);
505 if (xfer->nframes > frame_limit) {
513 if (xfer->nframes == 0) {
528 if (xfer->interval == 0) {
529 xfer->interval = edesc->bInterval;
537 if (xfer->interval < 4)
538 xfer->interval = 1;
539 else if (xfer->interval > 16)
540 xfer->interval = (1 << (16 - 4));
542 xfer->interval =
543 (1 << (xfer->interval - 4));
548 if (xfer->interval == 0) {
553 xfer->interval = 1;
556 xfer->fps_shift = 0;
559 while ((temp != 0) && (temp < xfer->interval)) {
560 xfer->fps_shift++;
569 xfer->fps_shift += 3;
581 if ((xfer->max_frame_size == 0) ||
582 (xfer->max_packet_size == 0)) {
589 xfer->max_packet_size = MIN_PKT;
590 xfer->max_packet_count = 1;
592 usbd_update_max_frame_size(xfer);
609 parm->bufsize = xfer->max_frame_size;
612 parm->bufsize *= xfer->nframes;
620 if (xfer->flags.proxy_buffer) {
623 parm->bufsize += (xfer->max_frame_size - 1);
625 if (parm->bufsize < xfer->max_frame_size) {
632 parm->bufsize -= (parm->bufsize % xfer->max_frame_size);
640 xfer->max_data_length = parm->bufsize;
645 n_frlengths = xfer->nframes;
649 xfer->flags_int.control_xfr = 1;
650 if (xfer->nframes == 0) {
656 xfer->nframes = 1;
658 xfer->nframes = 2;
662 if (xfer->nframes == 0) {
663 xfer->nframes = 1;
667 n_frlengths = xfer->nframes;
668 n_frbuffers = xfer->nframes;
677 if (xfer->max_data_length < REQ_SIZE) {
682 xfer->max_data_length -= REQ_SIZE;
689 xfer->frlengths = parm->xfer_length_ptr;
693 xfer->frbuffers = parm->xfer_page_cache_ptr;
697 xfer->max_frame_count = xfer->nframes;
704 if (!xfer->flags.ext_buffer) {
715 xfer->local_buffer = page_info.buffer;
717 usbd_xfer_set_frame_offset(xfer, 0, 0);
720 usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
728 xfer->local_buffer =
731 usbd_xfer_set_frame_offset(xfer, 0, 0);
734 usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
751 if (xfer->flags_int.bdma_enable) {
774 xfer->dma_page_ptr = parm->dma_page_ptr;
781 xfer->max_data_length = 0;
785 xfer->max_hc_frame_size =
787 (parm->hc_max_frame_size % xfer->max_frame_size));
789 if (xfer->max_hc_frame_size == 0) {
798 xfer->frbuffers[x].tag_parent =
799 &xfer->xroot->dma_parent_tag;
801 if (xfer->flags_int.bdma_enable &&
804 xfer->frbuffers + x,
818 xfer->max_hc_frame_size = 1;
819 xfer->max_frame_size = 1;
820 xfer->max_packet_size = 1;
821 xfer->max_data_length = 0;
822 xfer->nframes = 0;
823 xfer->max_frame_count = 0;
866 struct usb_xfer *xfer;
1039 xfer = USB_ADD_BYTES(buf, parm->size[0]);
1040 xfer->address = udev->address;
1041 xfer->priv_sc = priv_sc;
1042 xfer->xroot = info;
1044 usb_callout_init_mtx(&xfer->timeout_handle,
1048 * Setup a dummy xfer, hence we are
1050 * structure pointed to by "xfer"
1054 xfer = &udev->scratch.xfer_setup[0].dummy;
1055 (void)memset_s(xfer, sizeof(*xfer), 0, sizeof(*xfer));
1060 xfer->endpoint = ep;
1063 xfer->stream_id = setup->stream_id;
1065 parm->size[0] += sizeof(xfer[0]);
1066 parm->methods = xfer->endpoint->methods;
1067 parm->curr_xfer = xfer;
1090 if (xfer->endpoint->refcount_alloc >= USB_EP_REF_MAX)
1093 xfer->endpoint->refcount_alloc++;
1095 if (xfer->endpoint->refcount_alloc == 0)
1110 ppxfer[n] = xfer;
1270 /* free DMA maps in all "xfer->frbuffers" */
1301 struct usb_xfer *xfer;
1309 xfer = pxfer[n_setup];
1311 if (xfer == NULL)
1314 info = xfer->xroot;
1316 USB_XFER_LOCK(xfer);
1338 USB_XFER_UNLOCK(xfer);
1340 usbd_transfer_drain(xfer);
1343 if (xfer->flags_int.bdma_enable)
1351 xfer->endpoint->refcount_alloc--;
1354 usb_callout_drain(&xfer->timeout_handle);
1384 usbd_control_transfer_init(struct usb_xfer *xfer)
1390 usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
1394 xfer->flags_int.control_rem = UGETW(req.wLength);
1398 xfer->endpointno &= ~(UE_DIR_IN | UE_DIR_OUT);
1399 xfer->endpointno |=
1411 usbd_control_transfer_did_data(struct usb_xfer *xfer)
1416 if (xfer->flags_int.control_hdr != 0)
1420 usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
1423 return (xfer->flags_int.control_rem != UGETW(req.wLength));
1438 usbd_setup_ctrl_transfer(struct usb_xfer *xfer)
1443 if (xfer->flags.stall_pipe && xfer->flags_int.control_act) {
1445 xfer->flags_int.control_stall = 1;
1446 xfer->flags_int.control_act = 0;
1449 xfer->flags_int.control_stall = 0;
1453 if (xfer->nframes > 2) {
1461 (unsigned int)xfer->nframes);
1469 if (xfer->flags_int.control_act) {
1470 if (xfer->flags_int.control_hdr) {
1473 xfer->flags_int.control_hdr = 0;
1476 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
1477 usbd_control_transfer_init(xfer);
1482 len = xfer->sumlen;
1487 if (xfer->frlengths[0] != sizeof(struct usb_device_request)) {
1489 xfer->frlengths[0], sizeof(struct
1494 if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
1496 if (xfer->nframes != 1) {
1510 xfer->flags_int.control_rem = 0xFFFF;
1514 usbd_control_transfer_init(xfer);
1519 xfer->flags_int.control_hdr = 1;
1523 len = (xfer->sumlen - sizeof(struct usb_device_request));
1528 xfer->flags_int.control_did_data =
1529 usbd_control_transfer_did_data(xfer);
1533 if (len > xfer->flags_int.control_rem) {
1536 xfer->flags_int.control_rem);
1541 if (xfer->flags.force_short_xfer) {
1542 xfer->flags_int.control_rem = 0;
1544 if ((len != xfer->max_data_length) &&
1545 (len != xfer->flags_int.control_rem) &&
1546 (xfer->nframes != 1)) {
1551 xfer->flags_int.control_rem -= len;
1556 if ((xfer->flags_int.control_rem > 0) ||
1557 (xfer->flags.manual_status)) {
1559 xfer->flags_int.control_act = 1;
1562 if ((!xfer->flags_int.control_hdr) &&
1563 (xfer->nframes == 1)) {
1573 xfer->flags_int.control_act = 0;
1587 usbd_transfer_submit(struct usb_xfer *xfer)
1593 info = xfer->xroot;
1596 DPRINTF("xfer=%p, endpoint=%p, nframes=%d, dir=%s\n",
1597 xfer, xfer->endpoint, xfer->nframes, USB_GET_DATA_ISREAD(xfer) ?
1604 usb_dump_endpoint(xfer->endpoint);
1610 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1614 if (!xfer->flags_int.open) {
1615 xfer->flags_int.open = 1;
1620 (xfer->endpoint->methods->open) (xfer);
1624 xfer->flags_int.transferring = 1;
1628 usbd_transfer_power_ref(xfer, 1);
1634 if (xfer->wait_queue) {
1636 usbd_transfer_dequeue(xfer);
1640 xfer->flags_int.did_dma_delay = 0;
1643 xfer->flags_int.did_close = 0;
1647 xfer->flags_int.bdma_setup = 0;
1650 xfer->flags_int.can_cancel_immed = 0;
1653 xfer->sumlen = 0;
1654 xfer->actlen = 0;
1655 xfer->aframes = 0;
1658 xfer->error = USB_ERR_NORMAL_COMPLETION;
1667 usbd_transfer_done(xfer, USB_ERR_CANCELLED);
1673 if (xfer->nframes == 0) {
1674 if (xfer->flags.stall_pipe) {
1679 DPRINTF("xfer=%p nframes=0: stall "
1680 "or clear stall!\n", xfer);
1682 xfer->flags_int.can_cancel_immed = 1;
1684 usb_command_wrapper(&xfer->endpoint->
1685 endpoint_q[xfer->stream_id], xfer);
1690 usbd_transfer_done(xfer, USB_ERR_INVAL);
1696 for (x = 0; x != xfer->nframes; x++) {
1698 xfer->frlengths[x + xfer->max_frame_count] = xfer->frlengths[x];
1700 xfer->sumlen += xfer->frlengths[x];
1701 if (xfer->sumlen < xfer->frlengths[x]) {
1704 usbd_transfer_done(xfer, USB_ERR_INVAL);
1712 xfer->flags_int.short_xfer_ok = 0;
1713 xfer->flags_int.short_frames_ok = 0;
1717 if (xfer->flags_int.control_xfr) {
1718 if (usbd_setup_ctrl_transfer(xfer)) {
1720 usbd_transfer_done(xfer, USB_ERR_STALLED);
1729 if (USB_GET_DATA_ISREAD(xfer)) {
1730 if (xfer->flags.short_frames_ok) {
1731 xfer->flags_int.short_xfer_ok = 1;
1732 xfer->flags_int.short_frames_ok = 1;
1733 } else if (xfer->flags.short_xfer_ok) {
1734 xfer->flags_int.short_xfer_ok = 1;
1737 if (xfer->flags_int.control_xfr) {
1751 xfer->flags_int.short_frames_ok = 1;
1760 if (xfer->flags_int.bdma_enable) {
1762 usb_command_wrapper(&xfer->xroot->dma_q, xfer);
1770 usbd_pipe_enter(xfer);
1777 usbd_pipe_enter(struct usb_xfer *xfer)
1781 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1783 USB_BUS_LOCK(xfer->xroot->bus);
1785 ep = xfer->endpoint;
1790 xfer->flags_int.can_cancel_immed = 1;
1793 (ep->methods->enter) (xfer);
1796 if (xfer->error) {
1798 usbd_transfer_done(xfer, (usb_error_t)0);
1799 USB_BUS_UNLOCK(xfer->xroot->bus);
1804 usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], xfer);
1805 USB_BUS_UNLOCK(xfer->xroot->bus);
1816 usbd_transfer_start(struct usb_xfer *xfer)
1818 if (xfer == NULL) {
1822 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1826 if (!xfer->flags_int.started) {
1828 USB_BUS_LOCK(xfer->xroot->bus);
1829 xfer->flags_int.started = 1;
1830 USB_BUS_UNLOCK(xfer->xroot->bus);
1834 if (xfer->flags_int.transferring) {
1837 USB_BUS_LOCK(xfer->xroot->bus);
1839 usbd_callback_ss_done_defer(xfer);
1840 USB_BUS_UNLOCK(xfer->xroot->bus);
1852 usbd_transfer_stop(struct usb_xfer *xfer)
1856 if (xfer == NULL) {
1860 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1864 if (!xfer->flags_int.open) {
1865 if (xfer->flags_int.started) {
1868 USB_BUS_LOCK(xfer->xroot->bus);
1869 xfer->flags_int.started = 0;
1870 USB_BUS_UNLOCK(xfer->xroot->bus);
1876 USB_BUS_LOCK(xfer->xroot->bus);
1878 xfer->error = USB_ERR_CANCELLED;
1884 xfer->flags_int.open = 0;
1885 xfer->flags_int.started = 0;
1890 if (xfer->flags_int.transferring) {
1891 if (xfer->flags_int.can_cancel_immed &&
1892 (!xfer->flags_int.did_close)) {
1898 (xfer->endpoint->methods->close) (xfer);
1900 xfer->flags_int.did_close = 1;
1908 (xfer->endpoint->methods->close) (xfer);
1919 ep = xfer->endpoint;
1925 if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
1927 &ep->endpoint_q[xfer->stream_id], NULL);
1931 USB_BUS_UNLOCK(xfer->xroot->bus);
1944 usbd_transfer_pending(struct usb_xfer *xfer)
1949 if (xfer == NULL) {
1953 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1955 if (xfer->flags_int.transferring) {
1959 USB_BUS_LOCK(xfer->xroot->bus);
1960 if (xfer->wait_queue) {
1962 USB_BUS_UNLOCK(xfer->xroot->bus);
1965 info = xfer->xroot;
1968 if (pq->curr == xfer) {
1970 USB_BUS_UNLOCK(xfer->xroot->bus);
1974 USB_BUS_UNLOCK(xfer->xroot->bus);
1987 usbd_transfer_drain(struct usb_xfer *xfer)
1992 if (xfer == NULL) {
1996 if (xfer->xroot->xfer_mtx != &Giant) {
1997 USB_XFER_LOCK_ASSERT(xfer, MA_NOTOWNED);
1999 USB_XFER_LOCK(xfer);
2001 usbd_transfer_stop(xfer);
2003 while (usbd_transfer_pending(xfer) ||
2004 xfer->flags_int.doing_callback) {
2012 xfer->flags_int.draining = 1;
2018 (void)cv_wait(&xfer->xroot->cv_drain, xfer->xroot->xfer_mtx);
2020 USB_XFER_UNLOCK(xfer);
2024 usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
2026 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2028 return (&xfer->frbuffers[frindex]);
2032 usbd_xfer_get_frame_buffer(struct usb_xfer *xfer, usb_frcount_t frindex)
2036 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2038 usbd_get_page(&xfer->frbuffers[frindex], 0, &page_info);
2054 usbd_xfer_get_fps_shift(struct usb_xfer *xfer)
2056 return (xfer->fps_shift);
2060 usbd_xfer_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex)
2062 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2064 return (xfer->frlengths[frindex]);
2076 usbd_xfer_set_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
2079 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2082 xfer->frbuffers[frindex].buffer = ptr;
2083 usbd_xfer_set_frame_len(xfer, frindex, len);
2087 usbd_xfer_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
2090 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2093 *ptr = xfer->frbuffers[frindex].buffer;
2095 *len = xfer->frlengths[frindex];
2107 usbd_xfer_old_frame_length(struct usb_xfer *xfer, usb_frcount_t frindex)
2109 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2111 return (xfer->frlengths[frindex + xfer->max_frame_count]);
2115 usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes,
2119 *actlen = xfer->actlen;
2121 *sumlen = xfer->sumlen;
2123 *aframes = xfer->aframes;
2125 *nframes = xfer->nframes;
2135 usbd_xfer_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
2138 KASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "
2140 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2143 xfer->frbuffers[frindex].buffer =
2144 USB_ADD_BYTES(xfer->local_buffer, offset);
2148 usbd_xfer_set_interval(struct usb_xfer *xfer, int i)
2150 xfer->interval = i;
2154 usbd_xfer_set_timeout(struct usb_xfer *xfer, int t)
2156 xfer->timeout = t;
2160 usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
2162 xfer->nframes = n;
2166 usbd_xfer_max_frames(struct usb_xfer *xfer)
2168 return (xfer->max_frame_count);
2172 usbd_xfer_max_len(struct usb_xfer *xfer)
2174 return (xfer->max_data_length);
2178 usbd_xfer_max_framelen(struct usb_xfer *xfer)
2180 return (xfer->max_frame_size);
2184 usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex,
2187 KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
2189 xfer->frlengths[frindex] = len;
2227 usbd_callback_ss_done_defer(struct usb_xfer *xfer)
2229 struct usb_xfer_root *info = xfer->xroot;
2232 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2234 if (pq->curr != xfer) {
2235 usbd_transfer_enqueue(pq, xfer);
2266 struct usb_xfer *xfer = pq->curr;
2267 struct usb_xfer_root *info = xfer->xroot;
2302 xfer->flags_int.doing_callback = 1;
2308 if (!xfer->flags_int.transferring) {
2309 xfer->usb_state = USB_ST_SETUP;
2310 if (!xfer->flags_int.started) {
2316 if (usbd_callback_wrapper_sub(xfer)) {
2323 usbd_transfer_power_ref(xfer, -1);
2325 xfer->flags_int.transferring = 0;
2327 if (xfer->error) {
2328 xfer->usb_state = USB_ST_ERROR;
2331 xfer->usb_state = USB_ST_TRANSFERRED;
2334 if (xfer->flags_int.bdma_enable &&
2335 (!xfer->flags_int.bdma_no_post_sync)) {
2336 usb_bdma_post_sync(xfer);
2343 if (xfer->usb_state != USB_ST_SETUP) {
2345 usbpf_xfertap(xfer, USBPF_XFERTAP_DONE);
2350 (xfer->callback) (xfer, xfer->error);
2359 if ((!xfer->flags_int.open) &&
2360 (xfer->flags_int.started) &&
2361 (xfer->usb_state == USB_ST_ERROR)) {
2363 xfer->flags_int.doing_callback = 0;
2365 usb_command_wrapper(&info->done_q, xfer);
2371 xfer->flags_int.doing_callback = 0;
2376 if (xfer->flags_int.draining &&
2377 (!xfer->flags_int.transferring)) {
2379 xfer->flags_int.draining = 0;
2397 usb_dma_delay_done_cb(struct usb_xfer *xfer)
2399 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2401 DPRINTFN(3, "Completed %p\n", xfer);
2404 usbd_transfer_done(xfer, (usb_error_t)0);
2416 usbd_transfer_dequeue(struct usb_xfer *xfer)
2422 pq = xfer->wait_queue;
2424 TAILQ_REMOVE(&pq->head, xfer, wait_entry);
2425 xfer->wait_queue = NULL;
2439 usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
2447 if (xfer->wait_queue == NULL) {
2448 xfer->wait_queue = pq;
2449 TAILQ_INSERT_TAIL(&pq->head, xfer, wait_entry);
2466 usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error)
2468 struct usb_xfer_root *info = xfer->xroot;
2478 if (!xfer->flags_int.transferring) {
2481 xfer->flags_int.control_act = 0;
2485 if (xfer->error == USB_ERR_NORMAL_COMPLETION)
2486 xfer->error = error;
2489 usb_callout_stop(&xfer->timeout_handle);
2496 usbd_transfer_dequeue(xfer);
2508 if (pq->curr == xfer) {
2515 if (xfer->error == USB_ERR_CANCELLED) {
2517 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2518 } else if (xfer->error != USB_ERR_NORMAL_COMPLETION) {
2520 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2523 [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
2527 usbd_callback_ss_done_defer(xfer);
2534 * "xfer->interval" is greater than zero, and and the endpoint type is
2540 struct usb_xfer *xfer = arg;
2541 struct usb_endpoint *ep = xfer->endpoint;
2543 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2548 usbpf_xfertap(xfer, USBPF_XFERTAP_SUBMIT);
2552 xfer->flags_int.can_cancel_immed = 1;
2555 if (xfer->error == 0)
2556 (ep->methods->start) (xfer);
2559 if (xfer->error) {
2561 usbd_transfer_done(xfer, (usb_error_t)0);
2572 usbd_xfer_set_stall(struct usb_xfer *xfer)
2574 if (xfer == NULL) {
2578 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2581 USB_BUS_LOCK(xfer->xroot->bus);
2582 xfer->flags.stall_pipe = 1;
2583 USB_BUS_UNLOCK(xfer->xroot->bus);
2587 usbd_xfer_is_stalled(struct usb_xfer *xfer)
2589 return (xfer->endpoint->is_stalled);
2599 usbd_transfer_clear_stall(struct usb_xfer *xfer)
2601 if (xfer == NULL) {
2605 USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
2608 USB_BUS_LOCK(xfer->xroot->bus);
2610 xfer->flags.stall_pipe = 0;
2612 USB_BUS_UNLOCK(xfer->xroot->bus);
2624 struct usb_xfer *xfer;
2627 xfer = pq->curr;
2628 ep = xfer->endpoint;
2630 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2642 if (xfer->flags.stall_pipe) {
2647 xfer->flags.stall_pipe = 0;
2650 info = xfer->xroot;
2702 if (xfer->nframes == 0) {
2704 xfer->aframes = 0;
2705 usbd_transfer_done(xfer, (usb_error_t)0);
2720 if (xfer->interval > 0) {
2724 usbd_transfer_timeout_ms(xfer,
2726 xfer->interval);
2732 usbd_transfer_start_cb((void *)xfer);
2743 usbd_transfer_timeout_ms(struct usb_xfer *xfer,
2746 USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2749 usb_callout_reset(&xfer->timeout_handle,
2750 USB_MS_TO_TICKS(ms) + USB_CALLOUT_ZERO_TICKS, cb, xfer);
2771 usbd_callback_wrapper_sub(struct usb_xfer *xfer)
2777 bus = xfer->xroot->bus;
2779 if ((!xfer->flags_int.open) &&
2780 (!xfer->flags_int.did_close)) {
2783 (xfer->endpoint->methods->close) (xfer);
2786 xfer->flags_int.did_close = 1;
2793 if ((xfer->error != 0) && (!xfer->flags_int.did_dma_delay) &&
2794 ((xfer->error == USB_ERR_CANCELLED) ||
2795 (xfer->error == USB_ERR_TIMEOUT) ||
2800 xfer->flags_int.did_dma_delay = 1;
2803 xfer->flags_int.can_cancel_immed = 0;
2805 temp = usbd_get_dma_delay(xfer->xroot->udev);
2808 "on %p\n", temp, xfer);
2819 (bus->methods->start_dma_delay) (xfer);
2821 usbd_transfer_timeout_ms(xfer,
2830 if (xfer->aframes > xfer->nframes) {
2831 if (xfer->error == 0) {
2834 __FUNCTION__, xfer->aframes, xfer->nframes);
2837 xfer->aframes = xfer->nframes;
2841 xfer->actlen = 0;
2843 for (x = 0; x != xfer->aframes; x++) {
2844 xfer->actlen += xfer->frlengths[x];
2850 * of frames transferred, "xfer->aframes":
2852 for (; x < xfer->nframes; x++) {
2853 usbd_xfer_set_frame_len(xfer, x, 0);
2857 if (xfer->actlen > xfer->sumlen) {
2858 if (xfer->error == 0) {
2861 __FUNCTION__, xfer->actlen, xfer->sumlen);
2864 xfer->actlen = xfer->sumlen;
2867 DPRINTFN(1, "xfer=%p endpoint=%p sts=%d alen=%d, slen=%d, afrm=%d, nfrm=%d\n",
2868 xfer, xfer->endpoint, xfer->error, xfer->actlen, xfer->sumlen,
2869 xfer->aframes, xfer->nframes);
2871 if (xfer->error) {
2873 xfer->flags_int.control_act = 0;
2876 switch (xfer->error) {
2886 uhub_tt_buffer_reset_async_locked(xfer->xroot->udev, xfer->endpoint);
2892 if ((xfer->error != USB_ERR_CANCELLED) &&
2893 (xfer->flags.pipe_bof)) {
2894 DPRINTFN(2, "xfer=%p: Block On Failure "
2895 "on endpoint=%p\n", xfer, xfer->endpoint);
2900 if (xfer->actlen < xfer->sumlen) {
2902 xfer->flags_int.control_act = 0;
2904 if (!xfer->flags_int.short_xfer_ok) {
2905 xfer->error = USB_ERR_SHORT_XFER;
2906 if (xfer->flags.pipe_bof) {
2907 DPRINTFN(2, "xfer=%p: Block On Failure on "
2909 xfer, xfer->endpoint);
2918 if (xfer->flags_int.control_act) {
2919 DPRINTFN(5, "xfer=%p: Control transfer "
2920 "active on endpoint=%p\n", xfer, xfer->endpoint);
2926 ep = xfer->endpoint;
2933 if (ep->endpoint_q[xfer->stream_id].curr == xfer) {
2934 usb_command_wrapper(&ep->endpoint_q[xfer->stream_id], NULL);
2936 if ((ep->endpoint_q[xfer->stream_id].curr != NULL) ||
2937 (TAILQ_FIRST(&ep->endpoint_q[xfer->stream_id].head) != NULL)) {
2942 xfer->endpoint->is_synced = 0;
2957 usb_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
2961 if (xfer) {
2966 if (pq->curr != xfer) {
2967 usbd_transfer_enqueue(pq, xfer);
2988 xfer = TAILQ_FIRST(&pq->head);
2989 if (xfer) {
2990 TAILQ_REMOVE(&pq->head, xfer,
2992 xfer->wait_queue = NULL;
2993 pq->curr = xfer;
3032 struct usb_xfer *xfer;
3041 xfer = udev->ctrl_xfer[0];
3042 if (xfer) {
3043 USB_XFER_LOCK(xfer);
3045 ((xfer->address == udev->address) &&
3051 * NOTE: checking "xfer->address" and
3055 usbd_transfer_start(xfer);
3058 USB_XFER_UNLOCK(xfer);
3244 struct usb_xfer *xfer;
3254 xfer = ppxfer[n];
3255 if (xfer == NULL)
3257 xroot = xfer->xroot;
3399 usbd_xfer_softc(struct usb_xfer *xfer)
3401 return (xfer->priv_sc);
3405 usbd_xfer_get_priv(struct usb_xfer *xfer)
3407 return (xfer->priv_fifo);
3411 usbd_xfer_set_priv(struct usb_xfer *xfer, void *ptr)
3413 xfer->priv_fifo = ptr;
3417 usbd_xfer_state(struct usb_xfer *xfer)
3419 return (xfer->usb_state);
3423 usbd_xfer_set_flag(struct usb_xfer *xfer, int flag)
3427 xfer->flags.force_short_xfer = 1;
3430 xfer->flags.short_xfer_ok = 1;
3433 xfer->flags.short_frames_ok = 1;
3436 xfer->flags.manual_status = 1;
3442 usbd_xfer_clr_flag(struct usb_xfer *xfer, int flag)
3446 xfer->flags.force_short_xfer = 0;
3449 xfer->flags.short_xfer_ok = 0;
3452 xfer->flags.short_frames_ok = 0;
3455 xfer->flags.manual_status = 0;
3466 usbd_xfer_get_timestamp(struct usb_xfer *xfer)
3468 return (xfer->isoc_time_complete);
3476 usbd_xfer_maxp_was_clamped(struct usb_xfer *xfer)
3478 return (xfer->flags_int.maxp_was_clamped);
3489 usbd_xfer_get_isochronous_start_frame(struct usb_xfer *xfer, uint32_t frame_curr,
3498 delta = (xfer->endpoint->isoc_next - frame_curr) & frame_mask;
3505 if (xfer->endpoint->is_synced == 0 ||
3509 xfer->endpoint->isoc_next = (frame_curr + 2 * frame_ms + frame_min) & frame_mask;
3510 xfer->endpoint->is_synced = 1;
3519 *p_frame_start = xfer->endpoint->isoc_next & frame_mask;
3522 delta = xfer->endpoint->isoc_next - frame_curr + (frame_curr % frame_ms);
3526 switch (usbd_get_speed(xfer->xroot->udev)) {
3531 shift = usbd_xfer_get_fps_shift(xfer);
3536 duration = ((xfer->nframes << shift) + 7) / 8;
3539 xfer->isoc_time_complete =
3540 usb_isoc_time_expand(xfer->xroot->bus, frame_curr / frame_ms) +
3544 xfer->endpoint->isoc_next += duration * frame_ms;
3545 xfer->endpoint->isoc_next &= frame_mask;