Annotation of sys/dev/usb/usscanner.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 39:
! 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: */
! 56:
! 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>
! 64:
! 65: #include <dev/usb/usb.h>
! 66: #include <dev/usb/usbdi.h>
! 67: #include <dev/usb/usbdi_util.h>
! 68:
! 69: #include <dev/usb/usbdevs.h>
! 70:
! 71: #include <scsi/scsi_all.h>
! 72: #include <scsi/scsiconf.h>
! 73: #include <machine/bus.h>
! 74:
! 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
! 83:
! 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
! 100:
! 101: #define USSCANNER_CONFIG_NO 1
! 102: #define USSCANNER_IFACE_IDX 0
! 103:
! 104: #define USSCANNER_SCSIID_HOST 0x00
! 105: #define USSCANNER_SCSIID_DEVICE 0x01
! 106:
! 107: #define USSCANNER_MAX_TRANSFER_SIZE MAXBSIZE
! 108:
! 109: #define USSCANNER_TIMEOUT 2000
! 110:
! 111: struct scsipi_device usscanner_dev =
! 112: {
! 113: NULL, /* Use default error handler */
! 114: NULL, /* have a queue, served by this */
! 115: NULL, /* have no async handler */
! 116: NULL, /* Use default 'done' routine */
! 117: };
! 118:
! 119: struct usscanner_softc {
! 120: struct device sc_dev;
! 121: usbd_device_handle sc_udev;
! 122: usbd_interface_handle sc_iface;
! 123:
! 124: int sc_in_addr;
! 125: usbd_pipe_handle sc_in_pipe;
! 126:
! 127: int sc_intr_addr;
! 128: usbd_pipe_handle sc_intr_pipe;
! 129: usbd_xfer_handle sc_intr_xfer;
! 130: u_char sc_status;
! 131:
! 132: int sc_out_addr;
! 133: usbd_pipe_handle sc_out_pipe;
! 134:
! 135: usbd_xfer_handle sc_cmd_xfer;
! 136: void *sc_cmd_buffer;
! 137: usbd_xfer_handle sc_data_xfer;
! 138: void *sc_data_buffer;
! 139:
! 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
! 147:
! 148: struct scsipi_xfer *sc_xs;
! 149:
! 150: struct device *sc_child; /* child device, for detach */
! 151:
! 152: struct scsipi_link sc_link;
! 153: struct scsi_adapter sc_atapi_adapter;
! 154: #define sc_adapter sc_atapi_adapter
! 155:
! 156: int sc_refcnt;
! 157: char sc_dying;
! 158: };
! 159:
! 160:
! 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);
! 167: callback usscanner_intr_cb;
! 168: callback usscanner_cmd_cb;
! 169: callback usscanner_data_cb;
! 170: callback usscanner_sensecmd_cb;
! 171: callback usscanner_sensedata_cb;
! 172:
! 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);
! 177:
! 178: struct cfdriver usscanner_cd = {
! 179: NULL, "usscanner", DV_DULL
! 180: };
! 181:
! 182: const struct cfattach usscanner_ca = {
! 183: sizeof(struct usscanner_softc),
! 184: usscanner_match,
! 185: usscanner_attach,
! 186: usscanner_detach,
! 187: usscanner_activate,
! 188: };
! 189:
! 190: int
! 191: usscanner_match(struct device *parent, void *match, void *aux)
! 192: {
! 193: struct usb_attach_arg *uaa = aux;
! 194:
! 195: DPRINTFN(50,("usscanner_match\n"));
! 196:
! 197: if (uaa->iface != NULL)
! 198: return (UMATCH_NONE);
! 199:
! 200: if (uaa->vendor == USB_VENDOR_HP &&
! 201: uaa->product == USB_PRODUCT_HP_5300C)
! 202: return (UMATCH_VENDOR_PRODUCT);
! 203: else
! 204: return (UMATCH_NONE);
! 205: }
! 206:
! 207: void
! 208: 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;
! 213: usbd_device_handle dev = uaa->device;
! 214: usbd_interface_handle iface;
! 215: char *devinfop;
! 216: usbd_status err;
! 217: usb_endpoint_descriptor_t *ed;
! 218: u_int8_t epcount;
! 219: int i;
! 220:
! 221: DPRINTFN(10,("usscanner_attach: sc=%p\n", sc));
! 222:
! 223: devinfop = usbd_devinfo_alloc(dev, 0);
! 224: printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
! 225: usbd_devinfo_free(devinfop);
! 226:
! 227: err = usbd_set_config_no(dev, USSCANNER_CONFIG_NO, 1);
! 228: if (err) {
! 229: printf("%s: setting config no failed\n",
! 230: sc->sc_dev.dv_xname);
! 231: return;
! 232: }
! 233:
! 234: err = usbd_device2interface_handle(dev, USSCANNER_IFACE_IDX, &iface);
! 235: if (err) {
! 236: printf("%s: getting interface handle failed\n",
! 237: sc->sc_dev.dv_xname);
! 238: return;
! 239: }
! 240:
! 241: sc->sc_udev = dev;
! 242: sc->sc_iface = iface;
! 243:
! 244: epcount = 0;
! 245: (void)usbd_endpoint_count(iface, &epcount);
! 246:
! 247: sc->sc_in_addr = -1;
! 248: sc->sc_intr_addr = -1;
! 249: sc->sc_out_addr = -1;
! 250: for (i = 0; i < epcount; i++) {
! 251: ed = usbd_interface2endpoint_descriptor(iface, i);
! 252: if (ed == NULL) {
! 253: printf("%s: couldn't get ep %d\n",
! 254: sc->sc_dev.dv_xname, i);
! 255: return;
! 256: }
! 257: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 258: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 259: sc->sc_in_addr = ed->bEndpointAddress;
! 260: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 261: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
! 262: sc->sc_intr_addr = ed->bEndpointAddress;
! 263: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
! 264: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 265: sc->sc_out_addr = ed->bEndpointAddress;
! 266: }
! 267: }
! 268: if (sc->sc_in_addr == -1 || sc->sc_intr_addr == -1 ||
! 269: sc->sc_out_addr == -1) {
! 270: printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
! 271: return;
! 272: }
! 273:
! 274: err = usbd_open_pipe(sc->sc_iface, sc->sc_in_addr,
! 275: USBD_EXCLUSIVE_USE, &sc->sc_in_pipe);
! 276: if (err) {
! 277: printf("%s: open in pipe failed, err=%d\n",
! 278: sc->sc_dev.dv_xname, err);
! 279: return;
! 280: }
! 281:
! 282: /* The interrupt endpoint must be opened as a normal pipe. */
! 283: err = usbd_open_pipe(sc->sc_iface, sc->sc_intr_addr,
! 284: USBD_EXCLUSIVE_USE, &sc->sc_intr_pipe);
! 285:
! 286: if (err) {
! 287: printf("%s: open intr pipe failed, err=%d\n",
! 288: sc->sc_dev.dv_xname, err);
! 289: usscanner_cleanup(sc);
! 290: return;
! 291: }
! 292: err = usbd_open_pipe(sc->sc_iface, sc->sc_out_addr,
! 293: USBD_EXCLUSIVE_USE, &sc->sc_out_pipe);
! 294: if (err) {
! 295: printf("%s: open out pipe failed, err=%d\n",
! 296: sc->sc_dev.dv_xname, err);
! 297: usscanner_cleanup(sc);
! 298: return;
! 299: }
! 300:
! 301: sc->sc_cmd_xfer = usbd_alloc_xfer(uaa->device);
! 302: if (sc->sc_cmd_xfer == NULL) {
! 303: printf("%s: alloc cmd xfer failed, err=%d\n",
! 304: sc->sc_dev.dv_xname, err);
! 305: usscanner_cleanup(sc);
! 306: return;
! 307: }
! 308:
! 309: /* XXX too big */
! 310: sc->sc_cmd_buffer = usbd_alloc_buffer(sc->sc_cmd_xfer,
! 311: USSCANNER_MAX_TRANSFER_SIZE);
! 312: if (sc->sc_cmd_buffer == NULL) {
! 313: printf("%s: alloc cmd buffer failed, err=%d\n",
! 314: sc->sc_dev.dv_xname, err);
! 315: usscanner_cleanup(sc);
! 316: return;
! 317: }
! 318:
! 319: sc->sc_intr_xfer = usbd_alloc_xfer (uaa->device);
! 320: if (sc->sc_intr_xfer == NULL) {
! 321: printf("%s: alloc intr xfer failed, err=%d\n",
! 322: sc->sc_dev.dv_xname, err);
! 323: usscanner_cleanup(sc);
! 324: return;
! 325: }
! 326:
! 327: sc->sc_data_xfer = usbd_alloc_xfer(uaa->device);
! 328: if (sc->sc_data_xfer == NULL) {
! 329: printf("%s: alloc data xfer failed, err=%d\n",
! 330: sc->sc_dev.dv_xname, err);
! 331: usscanner_cleanup(sc);
! 332: return;
! 333: }
! 334: sc->sc_data_buffer = usbd_alloc_buffer(sc->sc_data_xfer,
! 335: USSCANNER_MAX_TRANSFER_SIZE);
! 336: if (sc->sc_data_buffer == NULL) {
! 337: printf("%s: alloc data buffer failed, err=%d\n",
! 338: sc->sc_dev.dv_xname, err);
! 339: usscanner_cleanup(sc);
! 340: return;
! 341: }
! 342:
! 343: /*
! 344: * Fill in the adapter.
! 345: */
! 346: sc->sc_adapter.scsipi_cmd = usscanner_scsipi_cmd;
! 347: sc->sc_adapter.scsipi_minphys = usscanner_scsipi_minphys;
! 348:
! 349: /*
! 350: * fill in the prototype scsipi_link.
! 351: */
! 352: sc->sc_link.flags &= ~SDEV_ATAPI;
! 353: sc->sc_link.adapter_buswidth = 2;
! 354: sc->sc_link.adapter_target = USSCANNER_SCSIID_HOST;
! 355:
! 356: sc->sc_link.adapter_softc = sc;
! 357: sc->sc_link.adapter = &sc->sc_adapter;
! 358: sc->sc_link.device = &usscanner_dev;
! 359: sc->sc_link.openings = 1;
! 360:
! 361: bzero(&saa, sizeof(saa));
! 362: saa.saa_sc_link = &sc->sc_link;
! 363:
! 364: sc->sc_child = config_found(&sc->sc_dev, &saa, scsiprint);
! 365:
! 366: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
! 367: &sc->sc_dev);
! 368:
! 369: DPRINTFN(10, ("usscanner_attach: %p\n", sc->sc_udev));
! 370: }
! 371:
! 372: int
! 373: usscanner_detach(struct device *self, int flags)
! 374: {
! 375: struct usscanner_softc *sc = (struct usscanner_softc *)self;
! 376: int rv, s;
! 377:
! 378: DPRINTF(("usscanner_detach: sc=%p flags=%d\n", sc, flags));
! 379:
! 380: sc->sc_dying = 1;
! 381: /* Abort all pipes. Causes processes waiting for transfer to wake. */
! 382: if (sc->sc_in_pipe != NULL)
! 383: usbd_abort_pipe(sc->sc_in_pipe);
! 384: if (sc->sc_intr_pipe != NULL)
! 385: usbd_abort_pipe(sc->sc_intr_pipe);
! 386: if (sc->sc_out_pipe != NULL)
! 387: usbd_abort_pipe(sc->sc_out_pipe);
! 388:
! 389: s = splusb();
! 390: if (--sc->sc_refcnt >= 0) {
! 391: /* Wait for processes to go away. */
! 392: usb_detach_wait(&sc->sc_dev);
! 393: }
! 394: splx(s);
! 395:
! 396: if (sc->sc_child != NULL)
! 397: rv = config_detach(sc->sc_child, flags);
! 398: else
! 399: rv = 0;
! 400:
! 401: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 402: &sc->sc_dev);
! 403:
! 404: return (rv);
! 405: }
! 406:
! 407: void
! 408: usscanner_cleanup(struct usscanner_softc *sc)
! 409: {
! 410: if (sc->sc_in_pipe != NULL) {
! 411: usbd_close_pipe(sc->sc_in_pipe);
! 412: sc->sc_in_pipe = NULL;
! 413: }
! 414: if (sc->sc_intr_pipe != NULL) {
! 415: usbd_close_pipe(sc->sc_intr_pipe);
! 416: sc->sc_intr_pipe = NULL;
! 417: }
! 418: if (sc->sc_out_pipe != NULL) {
! 419: usbd_close_pipe(sc->sc_out_pipe);
! 420: sc->sc_out_pipe = NULL;
! 421: }
! 422: if (sc->sc_cmd_xfer != NULL) {
! 423: usbd_free_xfer(sc->sc_cmd_xfer);
! 424: sc->sc_cmd_xfer = NULL;
! 425: }
! 426: if (sc->sc_data_xfer != NULL) {
! 427: usbd_free_xfer(sc->sc_data_xfer);
! 428: sc->sc_data_xfer = NULL;
! 429: }
! 430: }
! 431:
! 432: int
! 433: usscanner_activate(struct device *self, enum devact act)
! 434: {
! 435: struct usscanner_softc *sc = (struct usscanner_softc *)self;
! 436:
! 437: switch (act) {
! 438: case DVACT_ACTIVATE:
! 439: break;
! 440:
! 441: case DVACT_DEACTIVATE:
! 442: sc->sc_dying = 1;
! 443: break;
! 444: }
! 445: return (0);
! 446: }
! 447:
! 448: void
! 449: usscanner_scsipi_minphys(struct buf *bp)
! 450: {
! 451: if (bp->b_bcount > USSCANNER_MAX_TRANSFER_SIZE)
! 452: bp->b_bcount = USSCANNER_MAX_TRANSFER_SIZE;
! 453: minphys(bp);
! 454: }
! 455:
! 456: void
! 457: 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;
! 462: usbd_status err;
! 463:
! 464: /* fetch sense data */
! 465: memset(&sense_cmd, 0, sizeof(sense_cmd));
! 466: sense_cmd.opcode = REQUEST_SENSE;
! 467: sense_cmd.byte2 = sc_link->lun << SCSI_CMD_LUN_SHIFT;
! 468: sense_cmd.length = sizeof xs->sense;
! 469:
! 470: sc->sc_state = UAS_SENSECMD;
! 471: memcpy(sc->sc_cmd_buffer, &sense_cmd, sizeof sense_cmd);
! 472: 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,
! 474: usscanner_sensecmd_cb);
! 475: err = usbd_transfer(sc->sc_cmd_xfer);
! 476: if (err == USBD_IN_PROGRESS)
! 477: return;
! 478:
! 479: xs->error = XS_DRIVER_STUFFUP;
! 480: usscanner_done(sc);
! 481: }
! 482:
! 483: void
! 484: usscanner_intr_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 485: usbd_status status)
! 486: {
! 487: struct usscanner_softc *sc = priv;
! 488: int s;
! 489:
! 490: DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));
! 491:
! 492: #ifdef USSCANNER_DEBUG
! 493: if (sc->sc_state != UAS_STATUS) {
! 494: printf("%s: !UAS_STATUS\n", sc->sc_dev.dv_xname);
! 495: }
! 496: if (sc->sc_status != 0) {
! 497: 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 */
! 501:
! 502: sc->sc_state = UAS_IDLE;
! 503:
! 504: sc->sc_xs->xs_status |= XS_STS_DONE;
! 505: s = splbio();
! 506: scsipi_done(sc->sc_xs);
! 507: splx(s);
! 508: }
! 509:
! 510: void
! 511: usscanner_data_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 512: usbd_status status)
! 513: {
! 514: struct usscanner_softc *sc = priv;
! 515: struct scsipi_xfer *xs = sc->sc_xs;
! 516: u_int32_t len;
! 517:
! 518: DPRINTFN(10, ("usscanner_data_cb status=%d\n", status));
! 519:
! 520: #ifdef USSCANNER_DEBUG
! 521: if (sc->sc_state != UAS_DATA) {
! 522: printf("%s: !UAS_DATA\n", sc->sc_dev.dv_xname);
! 523: }
! 524: #endif
! 525:
! 526: usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
! 527:
! 528: xs->resid = xs->datalen - len;
! 529:
! 530: switch (status) {
! 531: case USBD_NORMAL_COMPLETION:
! 532: if (xs->xs_control & XS_CTL_DATA_IN)
! 533: memcpy(xs->data, sc->sc_data_buffer, len);
! 534: xs->error = XS_NOERROR;
! 535: break;
! 536: case USBD_TIMEOUT:
! 537: xs->error = XS_TIMEOUT;
! 538: break;
! 539: case USBD_CANCELLED:
! 540: if (xs->error == XS_SENSE) {
! 541: usscanner_sense(sc);
! 542: return;
! 543: }
! 544: break;
! 545: default:
! 546: xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
! 547: break;
! 548: }
! 549: usscanner_done(sc);
! 550: }
! 551:
! 552: void
! 553: usscanner_sensedata_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 554: usbd_status status)
! 555: {
! 556: struct usscanner_softc *sc = priv;
! 557: struct scsipi_xfer *xs = sc->sc_xs;
! 558: u_int32_t len;
! 559:
! 560: DPRINTFN(10, ("usscanner_sensedata_cb status=%d\n", status));
! 561:
! 562: #ifdef USSCANNER_DEBUG
! 563: if (sc->sc_state != UAS_SENSEDATA) {
! 564: printf("%s: !UAS_SENSEDATA\n", sc->sc_dev.dv_xname);
! 565: }
! 566: #endif
! 567:
! 568: usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
! 569:
! 570: switch (status) {
! 571: case USBD_NORMAL_COMPLETION:
! 572: memcpy(&xs->sense, sc->sc_data_buffer, len);
! 573: if (len < sizeof xs->sense)
! 574: xs->error = XS_SHORTSENSE;
! 575: break;
! 576: case USBD_TIMEOUT:
! 577: xs->error = XS_TIMEOUT;
! 578: break;
! 579: case USBD_CANCELLED:
! 580: xs->error = XS_RESET;
! 581: break;
! 582: default:
! 583: xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
! 584: break;
! 585: }
! 586: usscanner_done(sc);
! 587: }
! 588:
! 589: void
! 590: usscanner_done(struct usscanner_softc *sc)
! 591: {
! 592: struct scsipi_xfer *xs = sc->sc_xs;
! 593: usbd_status err;
! 594:
! 595: DPRINTFN(10,("usscanner_done: error=%d\n", sc->sc_xs->error));
! 596:
! 597: sc->sc_state = UAS_STATUS;
! 598: usbd_setup_xfer(sc->sc_intr_xfer, sc->sc_intr_pipe, sc, &sc->sc_status,
! 599: 1, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 600: USSCANNER_TIMEOUT, usscanner_intr_cb);
! 601: err = usbd_transfer(sc->sc_intr_xfer);
! 602: if (err == USBD_IN_PROGRESS)
! 603: return;
! 604: xs->error = XS_DRIVER_STUFFUP;
! 605: }
! 606:
! 607: void
! 608: usscanner_sensecmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 609: usbd_status status)
! 610: {
! 611: struct usscanner_softc *sc = priv;
! 612: struct scsipi_xfer *xs = sc->sc_xs;
! 613: usbd_status err;
! 614:
! 615: DPRINTFN(10, ("usscanner_sensecmd_cb status=%d\n", status));
! 616:
! 617: #ifdef USSCANNER_DEBUG
! 618: #ifdef notyet
! 619: if (usscannerdebug > 15)
! 620: xs->sc_link->flags |= DEBUGLEVEL;
! 621: #endif
! 622:
! 623: if (sc->sc_state != UAS_SENSECMD) {
! 624: printf("%s: !UAS_SENSECMD\n", sc->sc_dev.dv_xname);
! 625: xs->error = XS_DRIVER_STUFFUP;
! 626: goto done;
! 627: }
! 628: #endif
! 629:
! 630: switch (status) {
! 631: case USBD_NORMAL_COMPLETION:
! 632: break;
! 633: case USBD_TIMEOUT:
! 634: xs->error = XS_TIMEOUT;
! 635: goto done;
! 636: default:
! 637: xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
! 638: goto done;
! 639: }
! 640:
! 641: sc->sc_state = UAS_SENSEDATA;
! 642: usbd_setup_xfer(sc->sc_data_xfer, sc->sc_in_pipe, sc,
! 643: sc->sc_data_buffer,
! 644: sizeof xs->sense, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 645: USSCANNER_TIMEOUT, usscanner_sensedata_cb);
! 646: err = usbd_transfer(sc->sc_data_xfer);
! 647: if (err == USBD_IN_PROGRESS)
! 648: return;
! 649: xs->error = XS_DRIVER_STUFFUP;
! 650: done:
! 651: usscanner_done(sc);
! 652: }
! 653:
! 654: void
! 655: usscanner_cmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
! 656: usbd_status status)
! 657: {
! 658: struct usscanner_softc *sc = priv;
! 659: struct scsipi_xfer *xs = sc->sc_xs;
! 660: usbd_pipe_handle pipe;
! 661: usbd_status err;
! 662:
! 663: DPRINTFN(10, ("usscanner_cmd_cb status=%d\n", status));
! 664:
! 665: #ifdef USSCANNER_DEBUG
! 666: #ifdef notyet
! 667: if (usscannerdebug > 15)
! 668: xs->sc_link->flags |= DEBUGLEVEL;
! 669: #endif
! 670:
! 671: if (sc->sc_state != UAS_CMD) {
! 672: printf("%s: !UAS_CMD\n", sc->sc_dev.dv_xname);
! 673: xs->error = XS_DRIVER_STUFFUP;
! 674: goto done;
! 675: }
! 676: #endif
! 677:
! 678: switch (status) {
! 679: case USBD_NORMAL_COMPLETION:
! 680: break;
! 681: case USBD_TIMEOUT:
! 682: xs->error = XS_TIMEOUT;
! 683: goto done;
! 684: case USBD_CANCELLED:
! 685: goto done;
! 686: default:
! 687: xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
! 688: goto done;
! 689: }
! 690:
! 691: if (xs->datalen == 0) {
! 692: DPRINTFN(4, ("usscanner_cmd_cb: no data phase\n"));
! 693: xs->error = XS_NOERROR;
! 694: goto done;
! 695: }
! 696:
! 697: if (xs->xs_control & XS_CTL_DATA_IN) {
! 698: DPRINTFN(4, ("usscanner_cmd_cb: data in len=%d\n",
! 699: xs->datalen));
! 700: pipe = sc->sc_in_pipe;
! 701: } else {
! 702: DPRINTFN(4, ("usscanner_cmd_cb: data out len=%d\n",
! 703: xs->datalen));
! 704: memcpy(sc->sc_data_buffer, xs->data, xs->datalen);
! 705: pipe = sc->sc_out_pipe;
! 706: }
! 707: sc->sc_state = UAS_DATA;
! 708: usbd_setup_xfer(sc->sc_data_xfer, pipe, sc, sc->sc_data_buffer,
! 709: xs->datalen, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 710: xs->timeout, usscanner_data_cb);
! 711: err = usbd_transfer(sc->sc_data_xfer);
! 712: if (err == USBD_IN_PROGRESS)
! 713: return;
! 714: xs->error = XS_DRIVER_STUFFUP;
! 715:
! 716: done:
! 717: usscanner_done(sc);
! 718: }
! 719:
! 720: int
! 721: 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;
! 725: usbd_status err;
! 726:
! 727: #ifdef notyet
! 728: DPRINTFN(8, ("%s: usscanner_scsi_cmd: %d:%d "
! 729: "xs=%p cmd=0x%02x datalen=%d (quirks=0x%x, poll=%d)\n",
! 730: sc->sc_dev.dv_xname,
! 731: sc_link->scsipi_scsi.target, sc_link->scsipi_scsi.lun,
! 732: xs, xs->cmd->opcode, xs->datalen,
! 733: sc_link->quirks, xs->xs_control & XS_CTL_POLL));
! 734: #endif
! 735:
! 736: if (sc->sc_dying) {
! 737: xs->error = XS_DRIVER_STUFFUP;
! 738: goto done;
! 739: }
! 740:
! 741: #ifdef USSCANNER_DEBUG
! 742: #ifdef notyet
! 743: if (sc_link->scsipi_scsi.target != USSCANNER_SCSIID_DEVICE) {
! 744: DPRINTF(("%s: wrong SCSI ID %d\n", sc->sc_dev.dv_xname,
! 745: sc_link->scsipi_scsi.target));
! 746: xs->error = XS_DRIVER_STUFFUP;
! 747: goto done;
! 748: }
! 749: #endif
! 750: if (sc->sc_state != UAS_IDLE) {
! 751: printf("%s: !UAS_IDLE\n", sc->sc_dev.dv_xname);
! 752: xs->error = XS_DRIVER_STUFFUP;
! 753: goto done;
! 754: }
! 755: #endif
! 756:
! 757: if (xs->datalen > USSCANNER_MAX_TRANSFER_SIZE) {
! 758: printf("umass_cmd: large datalen, %d\n", xs->datalen);
! 759: xs->error = XS_DRIVER_STUFFUP;
! 760: goto done;
! 761: }
! 762:
! 763: DPRINTFN(4, ("usscanner_scsi_cmd: async cmdlen=%d datalen=%d\n",
! 764: xs->cmdlen, xs->datalen));
! 765: sc->sc_state = UAS_CMD;
! 766: sc->sc_xs = xs;
! 767: memcpy(sc->sc_cmd_buffer, xs->cmd, xs->cmdlen);
! 768: usbd_setup_xfer(sc->sc_cmd_xfer, sc->sc_out_pipe, sc, sc->sc_cmd_buffer,
! 769: xs->cmdlen, USBD_NO_COPY, USSCANNER_TIMEOUT, usscanner_cmd_cb);
! 770: err = usbd_transfer(sc->sc_cmd_xfer);
! 771: if (err != USBD_IN_PROGRESS) {
! 772: xs->error = XS_DRIVER_STUFFUP;
! 773: goto done;
! 774: }
! 775:
! 776: return (SUCCESSFULLY_QUEUED);
! 777:
! 778:
! 779: done:
! 780: sc->sc_state = UAS_IDLE;
! 781: xs->xs_status |= XS_STS_DONE;
! 782: scsipi_done(xs);
! 783: if (xs->xs_control & XS_CTL_POLL)
! 784: return (COMPLETE);
! 785: else
! 786: return (SUCCESSFULLY_QUEUED);
! 787: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to usscanner.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb