/*      $NetBSD: usscanner.c,v 1.50 2021/08/07 16:19:17 thorpej Exp $   */

/*
* Copyright (c) 2001 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson ([email protected]) and LLoyd Parkes.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* This driver is partly based on information taken from the Linux driver
* by John Fremlin, Oliver Neukum, and Jeremy Hall.
*/
/*
* Protocol:
* Send raw SCSI command on the bulk-out pipe.
* If output command then
*     send further data on the bulk-out pipe
* else if input command then
*     read data on the bulk-in pipe
* else
*     don't do anything.
* Read status byte on the interrupt pipe (which doesn't seem to be
* an interrupt pipe at all).  This operation sometimes times out.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: usscanner.c,v 1.50 2021/08/07 16:19:17 thorpej Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

#include "scsibus.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/lwp.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/buf.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>

#include <dev/usb/usbdevs.h>

#include <sys/scsiio.h>
#include <dev/scsipi/scsi_spc.h>
#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsiconf.h>
#include <dev/scsipi/atapiconf.h>

#ifdef USSCANNER_DEBUG
#define DPRINTF(x)      if (usscannerdebug) printf x
#define DPRINTFN(n,x)   if (usscannerdebug>(n)) printf x
int     usscannerdebug = 0;
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif


#define USSCANNER_CONFIG_NO             1
#define USSCANNER_IFACE_IDX             0

#define USSCANNER_SCSIID_HOST   0x00
#define USSCANNER_SCSIID_DEVICE 0x01

#define USSCANNER_MAX_TRANSFER_SIZE     MAXPHYS

#define USSCANNER_TIMEOUT 2000

struct usscanner_softc {
       device_t                sc_dev;
       struct usbd_device      *sc_udev;
       struct usbd_interface   *sc_iface;

       int                     sc_in_addr;
       struct usbd_pipe        *sc_in_pipe;

       int                     sc_intr_addr;
       struct usbd_pipe        *sc_intr_pipe;
       struct usbd_xfer        *sc_intr_xfer;
       u_char                  sc_status;

       int                     sc_out_addr;
       struct usbd_pipe        *sc_out_pipe;

       struct usbd_xfer        *sc_cmd_xfer;
       void                    *sc_cmd_buffer;
       struct usbd_xfer        *sc_datain_xfer;
       void                    *sc_datain_buffer;
       struct usbd_xfer        *sc_dataout_xfer;
       void                    *sc_dataout_buffer;

       int                     sc_state;
#define UAS_IDLE        0
#define UAS_CMD         1
#define UAS_DATA        2
#define UAS_SENSECMD    3
#define UAS_SENSEDATA   4
#define UAS_STATUS      5

       struct scsipi_xfer      *sc_xs;

       device_t                sc_child;       /* child device, for detach */

       struct scsipi_adapter   sc_adapter;
       struct scsipi_channel   sc_channel;

       int                     sc_refcnt;
       char                    sc_dying;
};


Static void usscanner_cleanup(struct usscanner_softc *);
Static void usscanner_scsipi_request(struct scsipi_channel *,
                               scsipi_adapter_req_t, void *);
Static void usscanner_scsipi_minphys(struct buf *);
Static void usscanner_done(struct usscanner_softc *);
Static void usscanner_sense(struct usscanner_softc *);
typedef void callback(struct usbd_xfer *, void *, usbd_status);
Static callback usscanner_intr_cb;
Static callback usscanner_cmd_cb;
Static callback usscanner_data_cb;
Static callback usscanner_sensecmd_cb;
Static callback usscanner_sensedata_cb;

static int usscanner_match(device_t, cfdata_t, void *);
static void usscanner_attach(device_t, device_t, void *);
static void usscanner_childdet(device_t, device_t);
static int usscanner_detach(device_t, int);
static int usscanner_activate(device_t, enum devact);

CFATTACH_DECL2_NEW(usscanner, sizeof(struct usscanner_softc),
   usscanner_match, usscanner_attach, usscanner_detach, usscanner_activate,
   NULL, usscanner_childdet);

static int
usscanner_match(device_t parent, cfdata_t match, void *aux)
{
       struct usb_attach_arg *uaa = aux;

       DPRINTFN(50,("usscanner_match\n"));

       if (uaa->uaa_vendor == USB_VENDOR_HP &&
           uaa->uaa_product == USB_PRODUCT_HP_5300C)
               return UMATCH_VENDOR_PRODUCT;
       else
               return UMATCH_NONE;
}

static void
usscanner_attach(device_t parent, device_t self, void *aux)
{
       struct usscanner_softc *sc = device_private(self);
       struct usb_attach_arg *uaa = aux;
       struct usbd_device *    dev = uaa->uaa_device;
       struct usbd_interface * iface;
       char                    *devinfop;
       usbd_status             err;
       usb_endpoint_descriptor_t *ed;
       uint8_t                 epcount;
       int                     i;
       int error;

       DPRINTFN(10,("usscanner_attach: sc=%p\n", sc));

       sc->sc_dev = self;

       aprint_naive("\n");
       aprint_normal("\n");

       devinfop = usbd_devinfo_alloc(dev, 0);
       aprint_normal_dev(self, "%s\n", devinfop);
       usbd_devinfo_free(devinfop);

       err = usbd_set_config_no(dev, USSCANNER_CONFIG_NO, 1);
       if (err) {
               aprint_error_dev(self, "failed to set configuration, err=%s\n",
                   usbd_errstr(err));
               return;
       }

       err = usbd_device2interface_handle(dev, USSCANNER_IFACE_IDX, &iface);
       if (err) {
               aprint_error_dev(self, "getting interface handle failed\n");
               return;
       }

       sc->sc_udev = dev;
       sc->sc_iface = iface;

       epcount = 0;
       (void)usbd_endpoint_count(iface, &epcount);

       sc->sc_in_addr = -1;
       sc->sc_intr_addr = -1;
       sc->sc_out_addr = -1;
       for (i = 0; i < epcount; i++) {
               ed = usbd_interface2endpoint_descriptor(iface, i);
               if (ed == NULL) {
                       aprint_error_dev(self, "couldn't get ep %d\n", i);
                       return;
               }
               if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
                   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                       sc->sc_in_addr = ed->bEndpointAddress;
               } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
                   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
                       sc->sc_intr_addr = ed->bEndpointAddress;
               } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
                          UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                       sc->sc_out_addr = ed->bEndpointAddress;
               }
       }
       if (sc->sc_in_addr == -1 || sc->sc_intr_addr == -1 ||
           sc->sc_out_addr == -1) {
               aprint_error_dev(self, "missing endpoint\n");
               return;
       }

       err = usbd_open_pipe(sc->sc_iface, sc->sc_in_addr,
                            USBD_EXCLUSIVE_USE, &sc->sc_in_pipe);
       if (err) {
               aprint_error_dev(self, "open in pipe failed, err=%d\n", err);
               return;
       }

       /* 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);

       if (err) {
               aprint_error_dev(self, "open intr pipe failed, err=%d\n", err);
               usscanner_cleanup(sc);
               return;
       }
       err = usbd_open_pipe(sc->sc_iface, sc->sc_out_addr,
                            USBD_EXCLUSIVE_USE, &sc->sc_out_pipe);
       if (err) {
               aprint_error_dev(self, "open out pipe failed, err=%d\n",  err);
               usscanner_cleanup(sc);
               return;
       }

       /* XXX too big */
       error = usbd_create_xfer(sc->sc_out_pipe, USSCANNER_MAX_TRANSFER_SIZE,
           0, 0, &sc->sc_cmd_xfer);
       if (error) {
               aprint_error_dev(self, "alloc cmd xfer failed, error=%d\n",
                   error);
               usscanner_cleanup(sc);
               return;
       }

       sc->sc_cmd_buffer = usbd_get_buffer(sc->sc_cmd_xfer);

       error = usbd_create_xfer(sc->sc_intr_pipe, 1, 0, 0, &sc->sc_intr_xfer);
       if (error) {
               aprint_error_dev(self, "alloc intr xfer failed, error=%d\n",
                   error);
               usscanner_cleanup(sc);
               return;
       }

       error = usbd_create_xfer(sc->sc_in_pipe, USSCANNER_MAX_TRANSFER_SIZE,
           0, 0, &sc->sc_datain_xfer);
       if (error) {
               aprint_error_dev(self, "alloc data xfer failed, error=%d\n",
                   error);
               usscanner_cleanup(sc);
               return;
       }
       sc->sc_datain_buffer = usbd_get_buffer(sc->sc_datain_xfer);

       error = usbd_create_xfer(sc->sc_out_pipe, USSCANNER_MAX_TRANSFER_SIZE,
           0, 0, &sc->sc_dataout_xfer);
       if (error) {
               aprint_error_dev(self, "alloc data xfer failed, err=%d\n", err);
               usscanner_cleanup(sc);
               return;
       }
       sc->sc_dataout_buffer = usbd_get_buffer(sc->sc_dataout_xfer);

       /*
        * Fill in the adapter.
        */
       sc->sc_adapter.adapt_request = usscanner_scsipi_request;
       sc->sc_adapter.adapt_dev = sc->sc_dev;
       sc->sc_adapter.adapt_nchannels = 1;
       sc->sc_adapter.adapt_openings = 1;
       sc->sc_adapter.adapt_max_periph = 1;
       sc->sc_adapter.adapt_minphys = usscanner_scsipi_minphys;

#if NSCSIBUS > 0
       /*
        * fill in the scsipi_channel.
        */
       sc->sc_channel.chan_adapter = &sc->sc_adapter;
       sc->sc_channel.chan_bustype = &scsi_bustype;
       sc->sc_channel.chan_channel = 0;
       sc->sc_channel.chan_ntargets = USSCANNER_SCSIID_DEVICE + 1;
       sc->sc_channel.chan_nluns = 1;
       sc->sc_channel.chan_id = USSCANNER_SCSIID_HOST;

       usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);

       sc->sc_child = config_found(sc->sc_dev, &sc->sc_channel, scsiprint,
           CFARGS_NONE);

       DPRINTFN(10, ("usscanner_attach: %p\n", sc->sc_udev));

       return;

#else
       /* No SCSI bus, just ignore it */
       usscanner_cleanup(sc);

       aprint_error_dev(self,
           "no scsibus configured, see usscanner(4) for details\n");

       return;

#endif
}

static void
usscanner_childdet(device_t self, device_t child)
{
       struct usscanner_softc *sc = device_private(self);

       KASSERT(sc->sc_child == NULL);
       sc->sc_child = NULL;
}

static int
usscanner_detach(device_t self, int flags)
{
       struct usscanner_softc *sc = device_private(self);
       int rv, s;

       DPRINTF(("usscanner_detach: sc=%p flags=%d\n", sc, flags));

       sc->sc_dying = 1;
       /* Abort all pipes.  Causes processes waiting for transfer to wake. */
       if (sc->sc_in_pipe != NULL)
               usbd_abort_pipe(sc->sc_in_pipe);
       if (sc->sc_intr_pipe != NULL)
               usbd_abort_pipe(sc->sc_intr_pipe);
       if (sc->sc_out_pipe != NULL)
               usbd_abort_pipe(sc->sc_out_pipe);

       s = splusb();
       if (--sc->sc_refcnt >= 0) {
               /* Wait for processes to go away. */
               usb_detach_waitold(sc->sc_dev);
       }
       splx(s);

       if (sc->sc_child != NULL)
               rv = config_detach(sc->sc_child, flags);
       else
               rv = 0;

       if (sc->sc_udev != NULL)
               usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
                   sc->sc_dev);

       return rv;
}

Static void
usscanner_cleanup(struct usscanner_softc *sc)
{
       if (sc->sc_cmd_xfer != NULL) {
               usbd_destroy_xfer(sc->sc_cmd_xfer);
               sc->sc_cmd_xfer = NULL;
       }
       if (sc->sc_datain_xfer != NULL) {
               usbd_destroy_xfer(sc->sc_datain_xfer);
               sc->sc_datain_xfer = NULL;
       }
       if (sc->sc_dataout_xfer != NULL) {
               usbd_destroy_xfer(sc->sc_dataout_xfer);
               sc->sc_dataout_xfer = NULL;
       }
       if (sc->sc_in_pipe != NULL) {
               usbd_close_pipe(sc->sc_in_pipe);
               sc->sc_in_pipe = NULL;
       }
       if (sc->sc_intr_pipe != NULL) {
               usbd_close_pipe(sc->sc_intr_pipe);
               sc->sc_intr_pipe = NULL;
       }
       if (sc->sc_out_pipe != NULL) {
               usbd_close_pipe(sc->sc_out_pipe);
               sc->sc_out_pipe = NULL;
       }
}

static int
usscanner_activate(device_t self, enum devact act)
{
       struct usscanner_softc *sc = device_private(self);

       switch (act) {
       case DVACT_DEACTIVATE:
               sc->sc_dying = 1;
               return 0;
       default:
               return EOPNOTSUPP;
       }
}

Static void
usscanner_scsipi_minphys(struct buf *bp)
{
       if (bp->b_bcount > USSCANNER_MAX_TRANSFER_SIZE)
               bp->b_bcount = USSCANNER_MAX_TRANSFER_SIZE;
       minphys(bp);
}

Static void
usscanner_sense(struct usscanner_softc *sc)
{
       struct scsipi_xfer *xs = sc->sc_xs;
       struct scsipi_periph *periph = xs->xs_periph;
       struct scsi_request_sense sense_cmd;
       usbd_status err;

       /* fetch sense data */
       memset(&sense_cmd, 0, sizeof(sense_cmd));
       sense_cmd.opcode = SCSI_REQUEST_SENSE;
       sense_cmd.byte2 = periph->periph_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->sc_cmd_buffer,
           sizeof(sense_cmd), 0, USSCANNER_TIMEOUT,
           usscanner_sensecmd_cb);
       err = usbd_transfer(sc->sc_cmd_xfer);
       if (err == USBD_IN_PROGRESS)
               return;

       xs->error = XS_DRIVER_STUFFUP;
       usscanner_done(sc);
}

Static void
usscanner_intr_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
       struct usscanner_softc *sc = priv;
       int s;

       DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));

#ifdef USSCANNER_DEBUG
       if (sc->sc_state != UAS_STATUS) {
               printf("%s: !UAS_STATUS\n", device_xname(sc->sc_dev));
       }
       if (sc->sc_status != 0) {
               printf("%s: status byte=0x%02x\n", device_xname(sc->sc_dev),
                   sc->sc_status);
       }
#endif
       /* XXX what should we do on non-0 status */

       sc->sc_state = UAS_IDLE;

       s = splbio();
       KERNEL_LOCK(1, curlwp);
       scsipi_done(sc->sc_xs);
       KERNEL_UNLOCK_ONE(curlwp);
       splx(s);
}

Static void
usscanner_data_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
       struct usscanner_softc *sc = priv;
       struct scsipi_xfer *xs = sc->sc_xs;
       uint32_t len;

       DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));

#ifdef USSCANNER_DEBUG
       if (sc->sc_state != UAS_DATA) {
               printf("%s: !UAS_DATA\n", device_xname(sc->sc_dev));
       }
#endif

       usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);

       xs->resid = xs->datalen - len;

       switch (status) {
       case USBD_NORMAL_COMPLETION:
               xs->error = XS_NOERROR;
               break;
       case USBD_TIMEOUT:
               xs->error = XS_TIMEOUT;
               break;
       case USBD_CANCELLED:
               if (xs->error == XS_SENSE) {
                       usscanner_sense(sc);
                       return;
               }
               break;
       default:
               xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
               break;
       }
       usscanner_done(sc);
}

Static void
usscanner_sensedata_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
       struct usscanner_softc *sc = priv;
       struct scsipi_xfer *xs = sc->sc_xs;
       uint32_t len;

       DPRINTFN(10, ("usscanner_sensedata_cb status=%d\n", status));

#ifdef USSCANNER_DEBUG
       if (sc->sc_state != UAS_SENSEDATA) {
               printf("%s: !UAS_SENSEDATA\n", device_xname(sc->sc_dev));
       }
#endif

       usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);

       switch (status) {
       case USBD_NORMAL_COMPLETION:
               memcpy(&xs->sense, sc->sc_datain_buffer, len);
               if (len < sizeof(xs->sense))
                       xs->error = XS_SHORTSENSE;
               break;
       case USBD_TIMEOUT:
               xs->error = XS_TIMEOUT;
               break;
       case USBD_CANCELLED:
               xs->error = XS_RESET;
               break;
       default:
               xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
               break;
       }
       usscanner_done(sc);
}

Static void
usscanner_done(struct usscanner_softc *sc)
{
       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->sc_status, 1,
           USBD_SHORT_XFER_OK, USSCANNER_TIMEOUT, usscanner_intr_cb);
       err = usbd_transfer(sc->sc_intr_xfer);
       if (err == USBD_IN_PROGRESS)
               return;
       xs->error = XS_DRIVER_STUFFUP;
}

Static void
usscanner_sensecmd_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
       struct usscanner_softc *sc = priv;
       struct scsipi_xfer *xs = sc->sc_xs;
       usbd_status err;

       DPRINTFN(10, ("usscanner_sensecmd_cb status=%d\n", status));

#ifdef USSCANNER_DEBUG
       if (usscannerdebug > 15)
               xs->xs_periph->periph_flags |= 1; /* XXX 1 */

       if (sc->sc_state != UAS_SENSECMD) {
               aprint_error_dev(sc->sc_dev, "!UAS_SENSECMD\n");
               xs->error = XS_DRIVER_STUFFUP;
               goto done;
       }
#endif

       switch (status) {
       case USBD_NORMAL_COMPLETION:
               break;
       case USBD_TIMEOUT:
               xs->error = XS_TIMEOUT;
               goto done;
       default:
               xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
               goto done;
       }

       sc->sc_state = UAS_SENSEDATA;
       usbd_setup_xfer(sc->sc_datain_xfer, sc, sc->sc_datain_buffer,
           sizeof(xs->sense), USBD_SHORT_XFER_OK,
           USSCANNER_TIMEOUT, usscanner_sensedata_cb);
       err = usbd_transfer(sc->sc_datain_xfer);
       if (err == USBD_IN_PROGRESS)
               return;
       xs->error = XS_DRIVER_STUFFUP;
done:
       usscanner_done(sc);
}

Static void
usscanner_cmd_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
       struct usscanner_softc *sc = priv;
       struct scsipi_xfer *xs = sc->sc_xs;
       struct usbd_xfer *dxfer;
       usbd_status err;

       DPRINTFN(10, ("usscanner_cmd_cb status=%d\n", status));

#ifdef USSCANNER_DEBUG
       if (usscannerdebug > 15)
               xs->xs_periph->periph_flags |= 1;       /* XXX 1 */

       if (sc->sc_state != UAS_CMD) {
               aprint_error_dev(sc->sc_dev, "!UAS_CMD\n");
               xs->error = XS_DRIVER_STUFFUP;
               goto done;
       }
#endif

       switch (status) {
       case USBD_NORMAL_COMPLETION:
               break;
       case USBD_TIMEOUT:
               xs->error = XS_TIMEOUT;
               goto done;
       case USBD_CANCELLED:
               goto done;
       default:
               xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
               goto done;
       }

       if (xs->datalen == 0) {
               DPRINTFN(4, ("usscanner_cmd_cb: no data phase\n"));
               xs->error = XS_NOERROR;
               goto done;
       }

       if (xs->xs_control & XS_CTL_DATA_IN) {
               DPRINTFN(4, ("usscanner_cmd_cb: data in len=%d\n",
                            xs->datalen));
               dxfer = sc->sc_datain_xfer;
       } else {
               DPRINTFN(4, ("usscanner_cmd_cb: data out len=%d\n",
                            xs->datalen));
               dxfer = sc->sc_dataout_xfer;
       }
       sc->sc_state = UAS_DATA;
       usbd_setup_xfer(dxfer, sc, xs->data, xs->datalen,
           USBD_SHORT_XFER_OK, xs->timeout, usscanner_data_cb);
       err = usbd_transfer(dxfer);
       if (err == USBD_IN_PROGRESS)
               return;
       xs->error = XS_DRIVER_STUFFUP;

done:
       usscanner_done(sc);
}

Static void
usscanner_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
   void *arg)
{
       struct scsipi_xfer *xs;
       struct usscanner_softc *sc =
           device_private(chan->chan_adapter->adapt_dev);
       usbd_status err;

       switch (req) {
       case ADAPTER_REQ_RUN_XFER:
               xs = arg;

               DPRINTFN(8, ("%s: usscanner_scsipi_request: %d:%d "
                   "xs=%p cmd=0x%02x datalen=%d (quirks=%#x, poll=%d)\n",
                   device_xname(sc->sc_dev),
                   xs->xs_periph->periph_target, xs->xs_periph->periph_lun,
                   xs, xs->cmd->opcode, xs->datalen,
                   xs->xs_periph->periph_quirks,
                   xs->xs_control & XS_CTL_POLL));

               if (sc->sc_dying) {
                       xs->error = XS_DRIVER_STUFFUP;
                       goto done;
               }

#ifdef USSCANNER_DEBUG
               if (xs->xs_periph->periph_target != USSCANNER_SCSIID_DEVICE) {
                       DPRINTF(("%s: wrong SCSI ID %d\n",
                           device_xname(sc->sc_dev),
                           xs->xs_periph->periph_target));
                       xs->error = XS_DRIVER_STUFFUP;
                       goto done;
               }
               if (sc->sc_state != UAS_IDLE) {
                       printf("%s: !UAS_IDLE\n", device_xname(sc->sc_dev));
                       xs->error = XS_DRIVER_STUFFUP;
                       goto done;
               }
#endif

               if (xs->datalen > USSCANNER_MAX_TRANSFER_SIZE) {
                       aprint_normal_dev(sc->sc_dev,
                           "usscanner_scsipi_request: large datalen, %d\n",
                           xs->datalen);
                       xs->error = XS_DRIVER_STUFFUP;
                       goto done;
               }

               DPRINTFN(4, ("%s: usscanner_scsipi_request: async cmdlen=%d"
                   " datalen=%d\n", device_xname(sc->sc_dev), 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->sc_cmd_buffer,
                   xs->cmdlen, 0, USSCANNER_TIMEOUT, usscanner_cmd_cb);
               err = usbd_transfer(sc->sc_cmd_xfer);
               if (err != USBD_IN_PROGRESS) {
                       xs->error = XS_DRIVER_STUFFUP;
                       goto done;
               }

               return;


done:
               sc->sc_state = UAS_IDLE;
               KERNEL_LOCK(1, curlwp);
               scsipi_done(xs);
               KERNEL_UNLOCK_ONE(curlwp);
               return;

       case ADAPTER_REQ_GROW_RESOURCES:
               /* XXX Not supported. */
               return;
       case ADAPTER_REQ_SET_XFER_MODE:
               /* XXX Not supported. */
               return;
       }

}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.