sys/dev/usb/usb_handle_request.c

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