root/dev/usb/usscanner.c

DEFINITIONS

1. usscanner_match
2. usscanner_attach
3. usscanner_detach
4. usscanner_cleanup
5. usscanner_activate
6. usscanner_scsipi_minphys
7. usscanner_sense
8. usscanner_intr_cb
9. usscanner_data_cb
10. usscanner_sensedata_cb
11. usscanner_done
12. usscanner_sensecmd_cb
13. usscanner_cmd_cb
14. usscanner_scsipi_cmd

    1 /*      $OpenBSD: usscanner.c,v 1.22 2007/06/14 10:11:16 mbalmer Exp $  */
    2 /*      $NetBSD: usscanner.c,v 1.6 2001/01/23 14:04:14 augustss Exp $   */
    4 /*
    5  * Copyright (c) 2001 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Lennart Augustsson (lennart@augustsson.net) and LLoyd Parkes.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * This driver is partly based on information taken from the Linux driver
   42  * by John Fremlin, Oliver Neukum, and Jeremy Hall.
   43  */
   44 /*
   45  * Protocol:
   46  * Send raw SCSI command on the bulk-out pipe.
   47  * If output command then
   48  *     send further data on the bulk-out pipe
   49  * else if input command then
   50  *     read data on the bulk-in pipe
   51  * else
   52  *     don't do anything.
   53  * Read status byte on the interrupt pipe (which doesn't seem to be
   54  * an interrupt pipe at all).  This operation sometimes times out.
   55  */
   57 #include <sys/param.h>
   58 #include <sys/systm.h>
   59 #include <sys/kernel.h>
   60 #include <sys/malloc.h>
   61 #include <sys/device.h>
   62 #include <sys/conf.h>
   63 #include <sys/buf.h>
   65 #include <dev/usb/usb.h>
   66 #include <dev/usb/usbdi.h>
   67 #include <dev/usb/usbdi_util.h>
   69 #include <dev/usb/usbdevs.h>
   71 #include <scsi/scsi_all.h>
   72 #include <scsi/scsiconf.h>
   73 #include <machine/bus.h>
   75 #ifdef USSCANNER_DEBUG
   76 #define DPRINTF(x)      do { if (usscannerdebug) printf x; } while (0)
   77 #define DPRINTFN(n,x)   do { if (usscannerdebug>(n)) printf x; } while (0)
   78 int     usscannerdebug = 0;
   79 #else
   80 #define DPRINTF(x)
   81 #define DPRINTFN(n,x)
   82 #endif
   84 #define XS_CTL_DATA_IN          SCSI_DATA_IN
   85 #define XS_CTL_DATA_OUT         SCSI_DATA_OUT
   86 #define scsipi_adapter          scsi_adapter
   87 #define scsipi_cmd              scsi_cmd
   88 #define scsipi_device           scsi_device
   89 #define scsipi_done             scsi_done
   90 #define scsipi_link             scsi_link
   91 #define scsipi_minphys          scsi_minphys
   92 #define scsipi_sense            scsi_sense
   93 #define scsipi_xfer             scsi_xfer
   94 #define show_scsipi_xs          show_scsi_xs
   95 #define show_scsipi_cmd         show_scsi_cmd
   96 #define xs_control              flags
   97 #define xs_status               status
   98 #define XS_STS_DONE             ITSDONE
   99 #define XS_CTL_POLL             SCSI_POLL
  101 #define USSCANNER_CONFIG_NO             1
  102 #define USSCANNER_IFACE_IDX             0
  104 #define USSCANNER_SCSIID_HOST   0x00
  105 #define USSCANNER_SCSIID_DEVICE 0x01
  107 #define USSCANNER_MAX_TRANSFER_SIZE     MAXBSIZE
  109 #define USSCANNER_TIMEOUT 2000
  111 struct scsipi_device usscanner_dev =
  112 {
NULL,                   /* Use default error handler */
NULL,                   /* have a queue, served by this */
NULL,                   /* have no async handler */
NULL,                   /* Use default 'done' routine */
  117 };
  119 struct usscanner_softc {
  120         struct device           sc_dev;
usbd_device_handle      sc_udev;
usbd_interface_handle   sc_iface;
  124         int                     sc_in_addr;
usbd_pipe_handle        sc_in_pipe;
  127         int                     sc_intr_addr;
usbd_pipe_handle        sc_intr_pipe;
usbd_xfer_handle        sc_intr_xfer;
u_char                  sc_status;
  132         int                     sc_out_addr;
usbd_pipe_handle        sc_out_pipe;
usbd_xfer_handle        sc_cmd_xfer;
  136         void                    *sc_cmd_buffer;
usbd_xfer_handle        sc_data_xfer;
  138         void                    *sc_data_buffer;
  140         int                     sc_state;
  141 #define UAS_IDLE        0
  142 #define UAS_CMD         1
  143 #define UAS_DATA        2
  144 #define UAS_SENSECMD    3
  145 #define UAS_SENSEDATA   4
  146 #define UAS_STATUS      5
  148         struct scsipi_xfer      *sc_xs;
  150         struct device           *sc_child;      /* child device, for detach */
  152         struct scsipi_link      sc_link;
  153         struct scsi_adapter     sc_atapi_adapter;
  154 #define sc_adapter sc_atapi_adapter
  156         int                     sc_refcnt;
  157         char                    sc_dying;
  158 };
  161 void usscanner_cleanup(struct usscanner_softc *sc);
  162 int usscanner_scsipi_cmd(struct scsipi_xfer *xs);
  163 void usscanner_scsipi_minphys(struct buf *bp);
  164 void usscanner_done(struct usscanner_softc *sc);
  165 void usscanner_sense(struct usscanner_softc *sc);
  166 typedef void callback(usbd_xfer_handle, usbd_private_handle, usbd_status);
callback usscanner_intr_cb;
callback usscanner_cmd_cb;
callback usscanner_data_cb;
callback usscanner_sensecmd_cb;
callback usscanner_sensedata_cb;
  173 int usscanner_match(struct device *, void *, void *); 
  174 void usscanner_attach(struct device *, struct device *, void *); 
  175 int usscanner_detach(struct device *, int); 
  176 int usscanner_activate(struct device *, enum devact); 
  178 struct cfdriver usscanner_cd = { 
NULL, "usscanner", DV_DULL 
  180 }; 
  182 const struct cfattach usscanner_ca = { 
  183         sizeof(struct usscanner_softc), 
usscanner_match, 
usscanner_attach, 
usscanner_detach, 
usscanner_activate, 
  188 };
  190 int
usscanner_match(struct device *parent, void *match, void *aux)
  192 {
  193         struct usb_attach_arg   *uaa = aux;
DPRINTFN(50,("usscanner_match\n"));
  197         if (uaa->iface != NULL)
  198                 return (UMATCH_NONE);
  200         if (uaa->vendor == USB_VENDOR_HP &&
uaa->product == USB_PRODUCT_HP_5300C)
  202                 return (UMATCH_VENDOR_PRODUCT);
  203         else
  204                 return (UMATCH_NONE);
  205 }
  207 void
usscanner_attach(struct device *parent, struct device *self, void *aux)
  209 {
  210         struct usscanner_softc  *sc = (struct usscanner_softc *)self;
  211         struct usb_attach_arg   *uaa = aux;
  212         struct scsibus_attach_args saa;
usbd_device_handle      dev = uaa->device;
usbd_interface_handle   iface;
  215         char                    *devinfop;
usbd_status             err;
usb_endpoint_descriptor_t *ed;
u_int8_t                epcount;
  219         int                     i;
DPRINTFN(10,("usscanner_attach: sc=%p\n", sc));
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, USSCANNER_CONFIG_NO, 1);
  228         if (err) {
printf("%s: setting config no failed\n",
sc->sc_dev.dv_xname);
  231                 return;
  232         }
err = usbd_device2interface_handle(dev, USSCANNER_IFACE_IDX, &iface);
  235         if (err) {
printf("%s: getting interface handle failed\n",
sc->sc_dev.dv_xname);
  238                 return;
  239         }
sc->sc_udev = dev;
sc->sc_iface = iface;
epcount = 0;
  245         (void)usbd_endpoint_count(iface, &epcount);
sc->sc_in_addr = -1;
sc->sc_intr_addr = -1;
sc->sc_out_addr = -1;
  250         for (i = 0; i < epcount; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
  252                 if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->sc_dev.dv_xname, i);
  255                         return;
  256                 }
  257                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_in_addr = ed->bEndpointAddress;
  260                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_addr = ed->bEndpointAddress;
  263                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_out_addr = ed->bEndpointAddress;
  266                 }
  267         }
  268         if (sc->sc_in_addr == -1 || sc->sc_intr_addr == -1 ||
sc->sc_out_addr == -1) {
printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
  271                 return;
  272         }
err = usbd_open_pipe(sc->sc_iface, sc->sc_in_addr,
USBD_EXCLUSIVE_USE, &sc->sc_in_pipe);
  276         if (err) {
printf("%s: open in pipe failed, err=%d\n",
sc->sc_dev.dv_xname, err);
  279                 return;
  280         }
  282         /* The interrupt endpoint must be opened as a normal pipe. */
err = usbd_open_pipe(sc->sc_iface, sc->sc_intr_addr,
USBD_EXCLUSIVE_USE, &sc->sc_intr_pipe);
  286         if (err) {
printf("%s: open intr pipe failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  290                 return;
  291         }
err = usbd_open_pipe(sc->sc_iface, sc->sc_out_addr,
USBD_EXCLUSIVE_USE, &sc->sc_out_pipe);
  294         if (err) {
printf("%s: open out pipe failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  298                 return;
  299         }
sc->sc_cmd_xfer = usbd_alloc_xfer(uaa->device);
  302         if (sc->sc_cmd_xfer == NULL) {
printf("%s: alloc cmd xfer failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  306                 return;
  307         }
  309         /* XXX too big */
sc->sc_cmd_buffer = usbd_alloc_buffer(sc->sc_cmd_xfer,
USSCANNER_MAX_TRANSFER_SIZE);
  312         if (sc->sc_cmd_buffer == NULL) {
printf("%s: alloc cmd buffer failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  316                 return;
  317         }
sc->sc_intr_xfer = usbd_alloc_xfer (uaa->device);
  320         if (sc->sc_intr_xfer == NULL) {
printf("%s: alloc intr xfer failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  324           return; 
  325         }
sc->sc_data_xfer = usbd_alloc_xfer(uaa->device);
  328         if (sc->sc_data_xfer == NULL) {
printf("%s: alloc data xfer failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  332                 return;
  333         }
sc->sc_data_buffer = usbd_alloc_buffer(sc->sc_data_xfer,
USSCANNER_MAX_TRANSFER_SIZE);
  336         if (sc->sc_data_buffer == NULL) {
printf("%s: alloc data buffer failed, err=%d\n",
sc->sc_dev.dv_xname, err);
usscanner_cleanup(sc);
  340                 return;
  341         }
  343         /*
  344          * Fill in the adapter.
  345          */
sc->sc_adapter.scsipi_cmd = usscanner_scsipi_cmd;
sc->sc_adapter.scsipi_minphys = usscanner_scsipi_minphys;
  349         /*
  350          * fill in the prototype scsipi_link.
  351          */
sc->sc_link.flags &= ~SDEV_ATAPI;
sc->sc_link.adapter_buswidth = 2;
sc->sc_link.adapter_target = USSCANNER_SCSIID_HOST;
sc->sc_link.adapter_softc = sc;
sc->sc_link.adapter = &sc->sc_adapter;
sc->sc_link.device = &usscanner_dev;
sc->sc_link.openings = 1;
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &sc->sc_link;
sc->sc_child = config_found(&sc->sc_dev, &saa, scsiprint);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  367                            &sc->sc_dev);
DPRINTFN(10, ("usscanner_attach: %p\n", sc->sc_udev));
  370 }
  372 int
usscanner_detach(struct device *self, int flags)
  374 {
  375         struct usscanner_softc *sc = (struct usscanner_softc *)self;
  376         int rv, s;
DPRINTF(("usscanner_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
  381         /* Abort all pipes.  Causes processes waiting for transfer to wake. */
  382         if (sc->sc_in_pipe != NULL)
usbd_abort_pipe(sc->sc_in_pipe);
  384         if (sc->sc_intr_pipe != NULL)
usbd_abort_pipe(sc->sc_intr_pipe);
  386         if (sc->sc_out_pipe != NULL)
usbd_abort_pipe(sc->sc_out_pipe);
s = splusb();
  390         if (--sc->sc_refcnt >= 0) {
  391                 /* Wait for processes to go away. */
usb_detach_wait(&sc->sc_dev);
  393         }
splx(s);
  396         if (sc->sc_child != NULL)
rv = config_detach(sc->sc_child, flags);
  398         else
rv = 0;
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  402                            &sc->sc_dev);
  404         return (rv);
  405 }
  407 void
usscanner_cleanup(struct usscanner_softc *sc)
  409 {
  410         if (sc->sc_in_pipe != NULL) {
usbd_close_pipe(sc->sc_in_pipe);
sc->sc_in_pipe = NULL;
  413         }
  414         if (sc->sc_intr_pipe != NULL) {
usbd_close_pipe(sc->sc_intr_pipe);
sc->sc_intr_pipe = NULL;
  417         }
  418         if (sc->sc_out_pipe != NULL) {
usbd_close_pipe(sc->sc_out_pipe);
sc->sc_out_pipe = NULL;
  421         }
  422         if (sc->sc_cmd_xfer != NULL) {
usbd_free_xfer(sc->sc_cmd_xfer);
sc->sc_cmd_xfer = NULL;
  425         }
  426         if (sc->sc_data_xfer != NULL) {
usbd_free_xfer(sc->sc_data_xfer);
sc->sc_data_xfer = NULL;
  429         }
  430 }
  432 int
usscanner_activate(struct device *self, enum devact act)
  434 {
  435         struct usscanner_softc *sc = (struct usscanner_softc *)self;
  437         switch (act) {
  438         case DVACT_ACTIVATE:
  439                 break;
  441         case DVACT_DEACTIVATE:
sc->sc_dying = 1;
  443                 break;
  444         }
  445         return (0);
  446 }
  448 void
usscanner_scsipi_minphys(struct buf *bp)
  450 {
  451         if (bp->b_bcount > USSCANNER_MAX_TRANSFER_SIZE)
bp->b_bcount = USSCANNER_MAX_TRANSFER_SIZE;
minphys(bp);
  454 }
  456 void
usscanner_sense(struct usscanner_softc *sc)
  458 {
  459         struct scsipi_xfer *xs = sc->sc_xs;
  460         struct scsipi_link *sc_link = xs->sc_link;
  461         struct scsipi_sense sense_cmd;
usbd_status err;
  464         /* fetch sense data */
memset(&sense_cmd, 0, sizeof(sense_cmd));
sense_cmd.opcode = REQUEST_SENSE;
sense_cmd.byte2 = sc_link->lun << SCSI_CMD_LUN_SHIFT;
sense_cmd.length = sizeof xs->sense;
sc->sc_state = UAS_SENSECMD;
memcpy(sc->sc_cmd_buffer, &sense_cmd, sizeof sense_cmd);
usbd_setup_xfer(sc->sc_cmd_xfer, sc->sc_out_pipe, sc, sc->sc_cmd_buffer,
  473             sizeof sense_cmd, USBD_NO_COPY, USSCANNER_TIMEOUT,
usscanner_sensecmd_cb);
err = usbd_transfer(sc->sc_cmd_xfer);
  476         if (err == USBD_IN_PROGRESS)
  477                 return;
xs->error = XS_DRIVER_STUFFUP;
usscanner_done(sc);
  481 }
  483 void
usscanner_intr_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
  486 {
  487         struct usscanner_softc *sc = priv;
  488         int s;
DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));
  492 #ifdef USSCANNER_DEBUG
  493         if (sc->sc_state != UAS_STATUS) {
printf("%s: !UAS_STATUS\n", sc->sc_dev.dv_xname);
  495         }
  496         if (sc->sc_status != 0) {
printf("%s: status byte=0x%02x\n", sc->sc_dev.dv_xname, sc->sc_status);
  498         }
  499 #endif
  500         /* XXX what should we do on non-0 status */
sc->sc_state = UAS_IDLE;
sc->sc_xs->xs_status |= XS_STS_DONE;
s = splbio();
scsipi_done(sc->sc_xs);
splx(s);
  508 }
  510 void
usscanner_data_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
  513 {
  514         struct usscanner_softc *sc = priv;
  515         struct scsipi_xfer *xs = sc->sc_xs;
u_int32_t len;
DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));
  520 #ifdef USSCANNER_DEBUG
  521         if (sc->sc_state != UAS_DATA) {
printf("%s: !UAS_DATA\n", sc->sc_dev.dv_xname);
  523         }
  524 #endif
usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
xs->resid = xs->datalen - len;
  530         switch (status) {
  531         case USBD_NORMAL_COMPLETION:
  532                 if (xs->xs_control & XS_CTL_DATA_IN)
memcpy(xs->data, sc->sc_data_buffer, len);
xs->error = XS_NOERROR;
  535                 break;
  536         case USBD_TIMEOUT:
xs->error = XS_TIMEOUT;
  538                 break;
  539         case USBD_CANCELLED:
  540                 if (xs->error == XS_SENSE) {
usscanner_sense(sc);
  542                         return;
  543                 }
  544                 break;
  545         default:
xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
  547                 break;
  548         }
usscanner_done(sc);
  550 }
  552 void
usscanner_sensedata_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
  555 {
  556         struct usscanner_softc *sc = priv;
  557         struct scsipi_xfer *xs = sc->sc_xs;
u_int32_t len;
DPRINTFN(10, ("usscanner_sensedata_cb status=%d\n", status));
  562 #ifdef USSCANNER_DEBUG
  563         if (sc->sc_state != UAS_SENSEDATA) {
printf("%s: !UAS_SENSEDATA\n", sc->sc_dev.dv_xname);
  565         }
  566 #endif
usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
  570         switch (status) {
  571         case USBD_NORMAL_COMPLETION:
memcpy(&xs->sense, sc->sc_data_buffer, len);
  573                 if (len < sizeof xs->sense)
xs->error = XS_SHORTSENSE;
  575                 break;
  576         case USBD_TIMEOUT:
xs->error = XS_TIMEOUT;
  578                 break;
  579         case USBD_CANCELLED:
xs->error = XS_RESET;
  581                 break;
  582         default:
xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
  584                 break;
  585         }
usscanner_done(sc);
  587 }
  589 void
usscanner_done(struct usscanner_softc *sc)
  591 {
  592         struct scsipi_xfer *xs = sc->sc_xs;
usbd_status err;
DPRINTFN(10,("usscanner_done: error=%d\n", sc->sc_xs->error));
sc->sc_state = UAS_STATUS;
usbd_setup_xfer(sc->sc_intr_xfer, sc->sc_intr_pipe, sc, &sc->sc_status,
  599             1, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USSCANNER_TIMEOUT, usscanner_intr_cb);
err = usbd_transfer(sc->sc_intr_xfer);
  602         if (err == USBD_IN_PROGRESS)
  603                 return;
xs->error = XS_DRIVER_STUFFUP;
  605 }
  607 void
usscanner_sensecmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
  610 {
  611         struct usscanner_softc *sc = priv;
  612         struct scsipi_xfer *xs = sc->sc_xs;
usbd_status err;
DPRINTFN(10, ("usscanner_sensecmd_cb status=%d\n", status));
  617 #ifdef USSCANNER_DEBUG
  618 #ifdef notyet
  619         if (usscannerdebug > 15)
xs->sc_link->flags |= DEBUGLEVEL;
  621 #endif
  623         if (sc->sc_state != UAS_SENSECMD) {
printf("%s: !UAS_SENSECMD\n", sc->sc_dev.dv_xname);
xs->error = XS_DRIVER_STUFFUP;
  626                 goto done;
  627         }
  628 #endif
  630         switch (status) {
  631         case USBD_NORMAL_COMPLETION:
  632                 break;
  633         case USBD_TIMEOUT:
xs->error = XS_TIMEOUT;
  635                 goto done;
  636         default:
xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
  638                 goto done;
  639         }
sc->sc_state = UAS_SENSEDATA;
usbd_setup_xfer(sc->sc_data_xfer, sc->sc_in_pipe, sc,
sc->sc_data_buffer,
  644             sizeof xs->sense, USBD_SHORT_XFER_OK | USBD_NO_COPY,
USSCANNER_TIMEOUT, usscanner_sensedata_cb);
err = usbd_transfer(sc->sc_data_xfer);
  647         if (err == USBD_IN_PROGRESS)
  648                 return;
xs->error = XS_DRIVER_STUFFUP;
done:
usscanner_done(sc);
  652 }
  654 void
usscanner_cmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
  657 {
  658         struct usscanner_softc *sc = priv;
  659         struct scsipi_xfer *xs = sc->sc_xs;
usbd_pipe_handle pipe;
usbd_status err;
DPRINTFN(10, ("usscanner_cmd_cb status=%d\n", status));
  665 #ifdef USSCANNER_DEBUG
  666 #ifdef notyet
  667         if (usscannerdebug > 15)
xs->sc_link->flags |= DEBUGLEVEL;
  669 #endif
  671         if (sc->sc_state != UAS_CMD) {
printf("%s: !UAS_CMD\n", sc->sc_dev.dv_xname);
xs->error = XS_DRIVER_STUFFUP;
  674                 goto done;
  675         }
  676 #endif
  678         switch (status) {
  679         case USBD_NORMAL_COMPLETION:
  680                 break;
  681         case USBD_TIMEOUT:
xs->error = XS_TIMEOUT;
  683                 goto done;
  684         case USBD_CANCELLED:
  685                 goto done;
  686         default:
xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
  688                 goto done;
  689         }
  691         if (xs->datalen == 0) {
DPRINTFN(4, ("usscanner_cmd_cb: no data phase\n"));
xs->error = XS_NOERROR;
  694                 goto done;
  695         }
  697         if (xs->xs_control & XS_CTL_DATA_IN) {
DPRINTFN(4, ("usscanner_cmd_cb: data in len=%d\n",
xs->datalen));
pipe = sc->sc_in_pipe;
  701         } else {
DPRINTFN(4, ("usscanner_cmd_cb: data out len=%d\n",
xs->datalen));
memcpy(sc->sc_data_buffer, xs->data, xs->datalen);
pipe = sc->sc_out_pipe;
  706         }
sc->sc_state = UAS_DATA;
usbd_setup_xfer(sc->sc_data_xfer, pipe, sc, sc->sc_data_buffer,
xs->datalen, USBD_SHORT_XFER_OK | USBD_NO_COPY,
xs->timeout, usscanner_data_cb);
err = usbd_transfer(sc->sc_data_xfer);
  712         if (err == USBD_IN_PROGRESS)
  713                 return;
xs->error = XS_DRIVER_STUFFUP;
done:
usscanner_done(sc);
  718 }
  720 int
usscanner_scsipi_cmd(struct scsipi_xfer *xs)
  722 {
  723         struct scsipi_link *sc_link = xs->sc_link;
  724         struct usscanner_softc *sc = sc_link->adapter_softc;
usbd_status err;
  727 #ifdef notyet
DPRINTFN(8, ("%s: usscanner_scsi_cmd: %d:%d "
  729             "xs=%p cmd=0x%02x datalen=%d (quirks=0x%x, poll=%d)\n",
sc->sc_dev.dv_xname,
sc_link->scsipi_scsi.target, sc_link->scsipi_scsi.lun,
xs, xs->cmd->opcode, xs->datalen,
sc_link->quirks, xs->xs_control & XS_CTL_POLL));
  734 #endif
  736         if (sc->sc_dying) {
xs->error = XS_DRIVER_STUFFUP;
  738                 goto done;
  739         }
  741 #ifdef USSCANNER_DEBUG
  742 #ifdef notyet
  743         if (sc_link->scsipi_scsi.target != USSCANNER_SCSIID_DEVICE) {
DPRINTF(("%s: wrong SCSI ID %d\n", sc->sc_dev.dv_xname,
sc_link->scsipi_scsi.target));
xs->error = XS_DRIVER_STUFFUP;
  747                 goto done;
  748         }
  749 #endif
  750         if (sc->sc_state != UAS_IDLE) {
printf("%s: !UAS_IDLE\n", sc->sc_dev.dv_xname);
xs->error = XS_DRIVER_STUFFUP;
  753                 goto done;
  754         }
  755 #endif
  757         if (xs->datalen > USSCANNER_MAX_TRANSFER_SIZE) {
printf("umass_cmd: large datalen, %d\n", xs->datalen);
xs->error = XS_DRIVER_STUFFUP;
  760                 goto done;
  761         }
DPRINTFN(4, ("usscanner_scsi_cmd: async cmdlen=%d datalen=%d\n",
xs->cmdlen, xs->datalen));
sc->sc_state = UAS_CMD;
sc->sc_xs = xs;
memcpy(sc->sc_cmd_buffer, xs->cmd, xs->cmdlen);
usbd_setup_xfer(sc->sc_cmd_xfer, sc->sc_out_pipe, sc, sc->sc_cmd_buffer,
xs->cmdlen, USBD_NO_COPY, USSCANNER_TIMEOUT, usscanner_cmd_cb);
err = usbd_transfer(sc->sc_cmd_xfer);
  771         if (err != USBD_IN_PROGRESS) {
xs->error = XS_DRIVER_STUFFUP;
  773                 goto done;
  774         }
  776         return (SUCCESSFULLY_QUEUED);
done:
sc->sc_state = UAS_IDLE;
xs->xs_status |= XS_STS_DONE;
scsipi_done(xs);
  783         if (xs->xs_control & XS_CTL_POLL)
  784                 return (COMPLETE);
  785         else
  786                 return (SUCCESSFULLY_QUEUED);
  787 }