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