1 /* $FreeBSD$ */ 2 /*- 3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 4 * 5 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #ifdef USB_GLOBAL_INCLUDE_FILE 30 #include USB_GLOBAL_INCLUDE_FILE 31 #else 32 #include <sys/stdint.h> 33 #include <sys/stddef.h> 34 #include <sys/param.h> 35 #include <sys/queue.h> 36 #include <sys/types.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/bus.h> 40 #include <sys/module.h> 41 #include <sys/lock.h> 42 #include <sys/mutex.h> 43 #include <sys/condvar.h> 44 #include <sys/sysctl.h> 45 #include <sys/sx.h> 46 #include <sys/unistd.h> 47 #include <sys/callout.h> 48 #include <sys/malloc.h> 49 #include <sys/priv.h> 50 51 #include <dev/usb/usb.h> 52 #include <dev/usb/usbdi.h> 53 #include <dev/usb/usbdi_util.h> 54 #include "usb_if.h" 55 56 #define USB_DEBUG_VAR usb_debug 57 58 #include <dev/usb/usb_core.h> 59 #include <dev/usb/usb_process.h> 60 #include <dev/usb/usb_busdma.h> 61 #include <dev/usb/usb_transfer.h> 62 #include <dev/usb/usb_device.h> 63 #include <dev/usb/usb_debug.h> 64 #include <dev/usb/usb_dynamic.h> 65 #include <dev/usb/usb_hub.h> 66 67 #include <dev/usb/usb_controller.h> 68 #include <dev/usb/usb_bus.h> 69 #endif /* USB_GLOBAL_INCLUDE_FILE */ 70 71 /* function prototypes */ 72 73 static uint8_t usb_handle_get_stall(struct usb_device *, uint8_t); 74 static usb_error_t usb_handle_remote_wakeup(struct usb_xfer *, uint8_t); 75 static usb_error_t usb_handle_request(struct usb_xfer *); 76 static usb_error_t usb_handle_set_config(struct usb_xfer *, uint8_t); 77 static usb_error_t usb_handle_set_stall(struct usb_xfer *, uint8_t, 78 uint8_t); 79 static usb_error_t usb_handle_iface_request(struct usb_xfer *, void **, 80 uint16_t *, struct usb_device_request, uint16_t, 81 uint8_t); 82 83 /*------------------------------------------------------------------------* 84 * usb_handle_request_callback 85 * 86 * This function is the USB callback for generic USB Device control 87 * transfers. 88 *------------------------------------------------------------------------*/ 89 void 90 usb_handle_request_callback(struct usb_xfer *xfer, usb_error_t error) 91 { 92 usb_error_t err; 93 94 /* check the current transfer state */ 95 96 switch (USB_GET_STATE(xfer)) { 97 case USB_ST_SETUP: 98 case USB_ST_TRANSFERRED: 99 100 /* handle the request */ 101 err = usb_handle_request(xfer); 102 103 if (err) { 104 105 if (err == USB_ERR_BAD_CONTEXT) { 106 /* we need to re-setup the control transfer */ 107 usb_needs_explore(xfer->xroot->bus, 0); 108 break; 109 } 110 goto tr_restart; 111 } 112 usbd_transfer_submit(xfer); 113 break; 114 115 default: 116 /* check if a control transfer is active */ 117 if (xfer->flags_int.control_rem != 0xFFFF) { 118 /* handle the request */ 119 err = usb_handle_request(xfer); 120 } 121 if (xfer->error != USB_ERR_CANCELLED) { 122 /* should not happen - try stalling */ 123 goto tr_restart; 124 } 125 break; 126 } 127 return; 128 129 tr_restart: 130 /* 131 * If a control transfer is active, stall it, and wait for the 132 * next control transfer. 133 */ 134 usbd_xfer_set_frame_len(xfer, 0, sizeof(struct usb_device_request)); 135 xfer->nframes = 1; 136 xfer->flags.manual_status = 1; 137 xfer->flags.force_short_xfer = 0; 138 usbd_xfer_set_stall(xfer); /* cancel previous transfer, if any */ 139 usbd_transfer_submit(xfer); 140 } 141 142 /*------------------------------------------------------------------------* 143 * usb_handle_set_config 144 * 145 * Returns: 146 * 0: Success 147 * Else: Failure 148 *------------------------------------------------------------------------*/ 149 static usb_error_t 150 usb_handle_set_config(struct usb_xfer *xfer, uint8_t conf_no) 151 { 152 struct usb_device *udev = xfer->xroot->udev; 153 usb_error_t err = 0; 154 uint8_t do_unlock; 155 156 /* 157 * We need to protect against other threads doing probe and 158 * attach: 159 */ 160 USB_XFER_UNLOCK(xfer); 161 162 /* Prevent re-enumeration */ 163 do_unlock = usbd_enum_lock(udev); 164 165 if (conf_no == USB_UNCONFIG_NO) { 166 conf_no = USB_UNCONFIG_INDEX; 167 } else { 168 /* 169 * The relationship between config number and config index 170 * is very simple in our case: 171 */ 172 conf_no--; 173 } 174 175 if (usbd_set_config_index(udev, conf_no)) { 176 DPRINTF("set config %d failed\n", conf_no); 177 err = USB_ERR_STALLED; 178 goto done; 179 } 180 if (usb_probe_and_attach(udev, USB_IFACE_INDEX_ANY)) { 181 DPRINTF("probe and attach failed\n"); 182 err = USB_ERR_STALLED; 183 goto done; 184 } 185 done: 186 if (do_unlock) 187 usbd_enum_unlock(udev); 188 USB_XFER_LOCK(xfer); 189 return (err); 190 } 191 192 static usb_error_t 193 usb_check_alt_setting(struct usb_device *udev, 194 struct usb_interface *iface, uint8_t alt_index) 195 { 196 uint8_t do_unlock; 197 usb_error_t err = 0; 198 199 /* Prevent re-enumeration */ 200 do_unlock = usbd_enum_lock(udev); 201 202 if (alt_index >= usbd_get_no_alts(udev->cdesc, iface->idesc)) 203 err = USB_ERR_INVAL; 204 205 if (do_unlock) 206 usbd_enum_unlock(udev); 207 208 return (err); 209 } 210 211 /*------------------------------------------------------------------------* 212 * usb_handle_iface_request 213 * 214 * Returns: 215 * 0: Success 216 * Else: Failure 217 *------------------------------------------------------------------------*/ 218 static usb_error_t 219 usb_handle_iface_request(struct usb_xfer *xfer, 220 void **ppdata, uint16_t *plen, 221 struct usb_device_request req, uint16_t off, uint8_t state) 222 { 223 struct usb_interface *iface; 224 struct usb_interface *iface_parent; /* parent interface */ 225 struct usb_device *udev = xfer->xroot->udev; 226 int error; 227 uint8_t iface_index; 228 uint8_t temp_state; 229 uint8_t do_unlock; 230 231 if ((req.bmRequestType & 0x1F) == UT_INTERFACE) { 232 iface_index = req.wIndex[0]; /* unicast */ 233 } else { 234 iface_index = 0; /* broadcast */ 235 } 236 237 /* 238 * We need to protect against other threads doing probe and 239 * attach: 240 */ 241 USB_XFER_UNLOCK(xfer); 242 243 /* Prevent re-enumeration */ 244 do_unlock = usbd_enum_lock(udev); 245 246 error = ENXIO; 247 248 tr_repeat: 249 iface = usbd_get_iface(udev, iface_index); 250 if ((iface == NULL) || 251 (iface->idesc == NULL)) { 252 /* end of interfaces non-existing interface */ 253 goto tr_stalled; 254 } 255 /* set initial state */ 256 257 temp_state = state; 258 259 /* forward request to interface, if any */ 260 261 if ((error != 0) && 262 (error != ENOTTY) && 263 (iface->subdev != NULL) && 264 device_is_attached(iface->subdev)) { 265 #if 0 266 DEVMETHOD(usb_handle_request, NULL); /* dummy */ 267 #endif 268 error = USB_HANDLE_REQUEST(iface->subdev, 269 &req, ppdata, plen, 270 off, &temp_state); 271 } 272 iface_parent = usbd_get_iface(udev, iface->parent_iface_index); 273 274 if ((iface_parent == NULL) || 275 (iface_parent->idesc == NULL)) { 276 /* non-existing interface */ 277 iface_parent = NULL; 278 } 279 /* forward request to parent interface, if any */ 280 281 if ((error != 0) && 282 (error != ENOTTY) && 283 (iface_parent != NULL) && 284 (iface_parent->subdev != NULL) && 285 ((req.bmRequestType & 0x1F) == UT_INTERFACE) && 286 (iface_parent->subdev != iface->subdev) && 287 device_is_attached(iface_parent->subdev)) { 288 error = USB_HANDLE_REQUEST(iface_parent->subdev, 289 &req, ppdata, plen, off, &temp_state); 290 } 291 if (error == 0) { 292 /* negativly adjust pointer and length */ 293 *ppdata = ((uint8_t *)(*ppdata)) - off; 294 *plen += off; 295 296 if ((state == USB_HR_NOT_COMPLETE) && 297 (temp_state == USB_HR_COMPLETE_OK)) 298 goto tr_short; 299 else 300 goto tr_valid; 301 } else if (error == ENOTTY) { 302 goto tr_stalled; 303 } 304 if ((req.bmRequestType & 0x1F) != UT_INTERFACE) { 305 iface_index++; /* iterate */ 306 goto tr_repeat; 307 } 308 if (state != USB_HR_NOT_COMPLETE) { 309 /* we are complete */ 310 goto tr_valid; 311 } 312 switch (req.bmRequestType) { 313 case UT_WRITE_INTERFACE: 314 switch (req.bRequest) { 315 case UR_SET_INTERFACE: 316 /* 317 * We assume that the endpoints are the same 318 * across the alternate settings. 319 * 320 * Reset the endpoints, because re-attaching 321 * only a part of the device is not possible. 322 */ 323 error = usb_check_alt_setting(udev, 324 iface, req.wValue[0]); 325 if (error) { 326 DPRINTF("alt setting does not exist %s\n", 327 usbd_errstr(error)); 328 goto tr_stalled; 329 } 330 error = usb_reset_iface_endpoints(udev, iface_index); 331 if (error) { 332 DPRINTF("alt setting failed %s\n", 333 usbd_errstr(error)); 334 goto tr_stalled; 335 } 336 /* update the current alternate setting */ 337 iface->alt_index = req.wValue[0]; 338 break; 339 340 default: 341 goto tr_stalled; 342 } 343 break; 344 345 case UT_READ_INTERFACE: 346 switch (req.bRequest) { 347 case UR_GET_INTERFACE: 348 *ppdata = &iface->alt_index; 349 *plen = 1; 350 break; 351 352 default: 353 goto tr_stalled; 354 } 355 break; 356 default: 357 goto tr_stalled; 358 } 359 tr_valid: 360 if (do_unlock) 361 usbd_enum_unlock(udev); 362 USB_XFER_LOCK(xfer); 363 return (0); 364 365 tr_short: 366 if (do_unlock) 367 usbd_enum_unlock(udev); 368 USB_XFER_LOCK(xfer); 369 return (USB_ERR_SHORT_XFER); 370 371 tr_stalled: 372 if (do_unlock) 373 usbd_enum_unlock(udev); 374 USB_XFER_LOCK(xfer); 375 return (USB_ERR_STALLED); 376 } 377 378 /*------------------------------------------------------------------------* 379 * usb_handle_stall 380 * 381 * Returns: 382 * 0: Success 383 * Else: Failure 384 *------------------------------------------------------------------------*/ 385 static usb_error_t 386 usb_handle_set_stall(struct usb_xfer *xfer, uint8_t ep, uint8_t do_stall) 387 { 388 struct usb_device *udev = xfer->xroot->udev; 389 usb_error_t err; 390 391 USB_XFER_UNLOCK(xfer); 392 err = usbd_set_endpoint_stall(udev, 393 usbd_get_ep_by_addr(udev, ep), do_stall); 394 USB_XFER_LOCK(xfer); 395 return (err); 396 } 397 398 /*------------------------------------------------------------------------* 399 * usb_handle_get_stall 400 * 401 * Returns: 402 * 0: Success 403 * Else: Failure 404 *------------------------------------------------------------------------*/ 405 static uint8_t 406 usb_handle_get_stall(struct usb_device *udev, uint8_t ea_val) 407 { 408 struct usb_endpoint *ep; 409 uint8_t halted; 410 411 ep = usbd_get_ep_by_addr(udev, ea_val); 412 if (ep == NULL) { 413 /* nothing to do */ 414 return (0); 415 } 416 USB_BUS_LOCK(udev->bus); 417 halted = ep->is_stalled; 418 USB_BUS_UNLOCK(udev->bus); 419 420 return (halted); 421 } 422 423 /*------------------------------------------------------------------------* 424 * usb_handle_remote_wakeup 425 * 426 * Returns: 427 * 0: Success 428 * Else: Failure 429 *------------------------------------------------------------------------*/ 430 static usb_error_t 431 usb_handle_remote_wakeup(struct usb_xfer *xfer, uint8_t is_on) 432 { 433 struct usb_device *udev; 434 struct usb_bus *bus; 435 436 udev = xfer->xroot->udev; 437 bus = udev->bus; 438 439 USB_BUS_LOCK(bus); 440 441 if (is_on) { 442 udev->flags.remote_wakeup = 1; 443 } else { 444 udev->flags.remote_wakeup = 0; 445 } 446 447 USB_BUS_UNLOCK(bus); 448 449 #if USB_HAVE_POWERD 450 /* In case we are out of sync, update the power state. */ 451 usb_bus_power_update(udev->bus); 452 #endif 453 return (0); /* success */ 454 } 455 456 /*------------------------------------------------------------------------* 457 * usb_handle_request 458 * 459 * Internal state sequence: 460 * 461 * USB_HR_NOT_COMPLETE -> USB_HR_COMPLETE_OK v USB_HR_COMPLETE_ERR 462 * 463 * Returns: 464 * 0: Ready to start hardware 465 * Else: Stall current transfer, if any 466 *------------------------------------------------------------------------*/ 467 static usb_error_t 468 usb_handle_request(struct usb_xfer *xfer) 469 { 470 struct usb_device_request req; 471 struct usb_device *udev; 472 const void *src_zcopy; /* zero-copy source pointer */ 473 const void *src_mcopy; /* non zero-copy source pointer */ 474 uint16_t off; /* data offset */ 475 uint16_t rem; /* data remainder */ 476 uint16_t max_len; /* max fragment length */ 477 uint16_t wValue; 478 uint8_t state; 479 uint8_t is_complete = 1; 480 usb_error_t err; 481 union { 482 uWord wStatus; 483 uint8_t buf[2]; 484 } temp; 485 486 /* 487 * Filter the USB transfer state into 488 * something which we understand: 489 */ 490 491 switch (USB_GET_STATE(xfer)) { 492 case USB_ST_SETUP: 493 state = USB_HR_NOT_COMPLETE; 494 495 if (!xfer->flags_int.control_act) { 496 /* nothing to do */ 497 goto tr_stalled; 498 } 499 break; 500 case USB_ST_TRANSFERRED: 501 if (!xfer->flags_int.control_act) { 502 state = USB_HR_COMPLETE_OK; 503 } else { 504 state = USB_HR_NOT_COMPLETE; 505 } 506 break; 507 default: 508 state = USB_HR_COMPLETE_ERR; 509 break; 510 } 511 512 /* reset frame stuff */ 513 514 usbd_xfer_set_frame_len(xfer, 0, 0); 515 516 usbd_xfer_set_frame_offset(xfer, 0, 0); 517 usbd_xfer_set_frame_offset(xfer, sizeof(req), 1); 518 519 /* get the current request, if any */ 520 521 usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req)); 522 523 if (xfer->flags_int.control_rem == 0xFFFF) { 524 /* first time - not initialised */ 525 rem = UGETW(req.wLength); 526 off = 0; 527 } else { 528 /* not first time - initialised */ 529 rem = xfer->flags_int.control_rem; 530 off = UGETW(req.wLength) - rem; 531 } 532 533 /* set some defaults */ 534 535 max_len = 0; 536 src_zcopy = NULL; 537 src_mcopy = NULL; 538 udev = xfer->xroot->udev; 539 540 /* get some request fields decoded */ 541 542 wValue = UGETW(req.wValue); 543 544 DPRINTF("req 0x%02x 0x%02x 0x%04x 0x%04x " 545 "off=0x%x rem=0x%x, state=%d\n", req.bmRequestType, 546 req.bRequest, wValue, UGETW(req.wIndex), off, rem, state); 547 548 /* demultiplex the control request */ 549 550 switch (req.bmRequestType) { 551 case UT_READ_DEVICE: 552 if (state != USB_HR_NOT_COMPLETE) { 553 break; 554 } 555 switch (req.bRequest) { 556 case UR_GET_DESCRIPTOR: 557 goto tr_handle_get_descriptor; 558 case UR_GET_CONFIG: 559 goto tr_handle_get_config; 560 case UR_GET_STATUS: 561 goto tr_handle_get_status; 562 default: 563 goto tr_stalled; 564 } 565 break; 566 567 case UT_WRITE_DEVICE: 568 switch (req.bRequest) { 569 case UR_SET_ADDRESS: 570 goto tr_handle_set_address; 571 case UR_SET_CONFIG: 572 goto tr_handle_set_config; 573 case UR_CLEAR_FEATURE: 574 switch (wValue) { 575 case UF_DEVICE_REMOTE_WAKEUP: 576 goto tr_handle_clear_wakeup; 577 default: 578 goto tr_stalled; 579 } 580 break; 581 case UR_SET_FEATURE: 582 switch (wValue) { 583 case UF_DEVICE_REMOTE_WAKEUP: 584 goto tr_handle_set_wakeup; 585 default: 586 goto tr_stalled; 587 } 588 break; 589 default: 590 goto tr_stalled; 591 } 592 break; 593 594 case UT_WRITE_ENDPOINT: 595 switch (req.bRequest) { 596 case UR_CLEAR_FEATURE: 597 switch (wValue) { 598 case UF_ENDPOINT_HALT: 599 goto tr_handle_clear_halt; 600 default: 601 goto tr_stalled; 602 } 603 break; 604 case UR_SET_FEATURE: 605 switch (wValue) { 606 case UF_ENDPOINT_HALT: 607 goto tr_handle_set_halt; 608 default: 609 goto tr_stalled; 610 } 611 break; 612 default: 613 goto tr_stalled; 614 } 615 break; 616 617 case UT_READ_ENDPOINT: 618 switch (req.bRequest) { 619 case UR_GET_STATUS: 620 goto tr_handle_get_ep_status; 621 default: 622 goto tr_stalled; 623 } 624 break; 625 default: 626 /* we use "USB_ADD_BYTES" to de-const the src_zcopy */ 627 err = usb_handle_iface_request(xfer, 628 USB_ADD_BYTES(&src_zcopy, 0), 629 &max_len, req, off, state); 630 if (err == 0) { 631 is_complete = 0; 632 goto tr_valid; 633 } else if (err == USB_ERR_SHORT_XFER) { 634 goto tr_valid; 635 } 636 /* 637 * Reset zero-copy pointer and max length 638 * variable in case they were unintentionally 639 * set: 640 */ 641 src_zcopy = NULL; 642 max_len = 0; 643 644 /* 645 * Check if we have a vendor specific 646 * descriptor: 647 */ 648 goto tr_handle_get_descriptor; 649 } 650 goto tr_valid; 651 652 tr_handle_get_descriptor: 653 err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len); 654 if (err) 655 goto tr_stalled; 656 if (src_zcopy == NULL) 657 goto tr_stalled; 658 goto tr_valid; 659 660 tr_handle_get_config: 661 temp.buf[0] = udev->curr_config_no; 662 src_mcopy = temp.buf; 663 max_len = 1; 664 goto tr_valid; 665 666 tr_handle_get_status: 667 668 wValue = 0; 669 670 USB_BUS_LOCK(udev->bus); 671 if (udev->flags.remote_wakeup) { 672 wValue |= UDS_REMOTE_WAKEUP; 673 } 674 if (udev->flags.self_powered) { 675 wValue |= UDS_SELF_POWERED; 676 } 677 USB_BUS_UNLOCK(udev->bus); 678 679 USETW(temp.wStatus, wValue); 680 src_mcopy = temp.wStatus; 681 max_len = sizeof(temp.wStatus); 682 goto tr_valid; 683 684 tr_handle_set_address: 685 if (state == USB_HR_NOT_COMPLETE) { 686 if (wValue >= 0x80) { 687 /* invalid value */ 688 goto tr_stalled; 689 } else if (udev->curr_config_no != 0) { 690 /* we are configured ! */ 691 goto tr_stalled; 692 } 693 } else if (state != USB_HR_NOT_COMPLETE) { 694 udev->address = (wValue & 0x7F); 695 goto tr_bad_context; 696 } 697 goto tr_valid; 698 699 tr_handle_set_config: 700 if (state == USB_HR_NOT_COMPLETE) { 701 if (usb_handle_set_config(xfer, req.wValue[0])) { 702 goto tr_stalled; 703 } 704 } 705 goto tr_valid; 706 707 tr_handle_clear_halt: 708 if (state == USB_HR_NOT_COMPLETE) { 709 if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) { 710 goto tr_stalled; 711 } 712 } 713 goto tr_valid; 714 715 tr_handle_clear_wakeup: 716 if (state == USB_HR_NOT_COMPLETE) { 717 if (usb_handle_remote_wakeup(xfer, 0)) { 718 goto tr_stalled; 719 } 720 } 721 goto tr_valid; 722 723 tr_handle_set_halt: 724 if (state == USB_HR_NOT_COMPLETE) { 725 if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) { 726 goto tr_stalled; 727 } 728 } 729 goto tr_valid; 730 731 tr_handle_set_wakeup: 732 if (state == USB_HR_NOT_COMPLETE) { 733 if (usb_handle_remote_wakeup(xfer, 1)) { 734 goto tr_stalled; 735 } 736 } 737 goto tr_valid; 738 739 tr_handle_get_ep_status: 740 if (state == USB_HR_NOT_COMPLETE) { 741 temp.wStatus[0] = 742 usb_handle_get_stall(udev, req.wIndex[0]); 743 temp.wStatus[1] = 0; 744 src_mcopy = temp.wStatus; 745 max_len = sizeof(temp.wStatus); 746 } 747 goto tr_valid; 748 749 tr_valid: 750 if (state != USB_HR_NOT_COMPLETE) { 751 goto tr_stalled; 752 } 753 /* subtract offset from length */ 754 755 max_len -= off; 756 757 /* Compute the real maximum data length */ 758 759 if (max_len > xfer->max_data_length) { 760 max_len = usbd_xfer_max_len(xfer); 761 } 762 if (max_len > rem) { 763 max_len = rem; 764 } 765 /* 766 * If the remainder is greater than the maximum data length, 767 * we need to truncate the value for the sake of the 768 * comparison below: 769 */ 770 if (rem > xfer->max_data_length) { 771 rem = usbd_xfer_max_len(xfer); 772 } 773 if ((rem != max_len) && (is_complete != 0)) { 774 /* 775 * If we don't transfer the data we can transfer, then 776 * the transfer is short ! 777 */ 778 xfer->flags.force_short_xfer = 1; 779 xfer->nframes = 2; 780 } else { 781 /* 782 * Default case 783 */ 784 xfer->flags.force_short_xfer = 0; 785 xfer->nframes = max_len ? 2 : 1; 786 } 787 if (max_len > 0) { 788 if (src_mcopy) { 789 src_mcopy = USB_ADD_BYTES(src_mcopy, off); 790 usbd_copy_in(xfer->frbuffers + 1, 0, 791 src_mcopy, max_len); 792 usbd_xfer_set_frame_len(xfer, 1, max_len); 793 } else { 794 usbd_xfer_set_frame_data(xfer, 1, 795 USB_ADD_BYTES(src_zcopy, off), max_len); 796 } 797 } else { 798 /* the end is reached, send status */ 799 xfer->flags.manual_status = 0; 800 usbd_xfer_set_frame_len(xfer, 1, 0); 801 } 802 DPRINTF("success\n"); 803 return (0); /* success */ 804 805 tr_stalled: 806 DPRINTF("%s\n", (state != USB_HR_NOT_COMPLETE) ? 807 "complete" : "stalled"); 808 return (USB_ERR_STALLED); 809 810 tr_bad_context: 811 DPRINTF("bad context\n"); 812 return (USB_ERR_BAD_CONTEXT); 813 } 814