sys/dev/usb/usb_handle_request.c

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