usscanner.c revision 1.2
1 /* $NetBSD: usscanner.c,v 1.2 2001/01/11 06:20:04 augustss Exp $ */ 2 3 /* 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart (at) augustsson.net) and LLoyd Parkes. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * This driver is partly based on information taken from the Linux driver 41 * by John Fremlin, Oliver Neukum, and Jeremy Hall. 42 */ 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/kernel.h> 47 #include <sys/malloc.h> 48 #include <sys/device.h> 49 #include <sys/conf.h> 50 #include <sys/buf.h> 51 52 #include <dev/usb/usb.h> 53 #include <dev/usb/usbdi.h> 54 #include <dev/usb/usbdi_util.h> 55 56 #include <dev/usb/usbdevs.h> 57 58 #include <sys/scsiio.h> 59 #include <dev/scsipi/scsi_all.h> 60 #include <dev/scsipi/scsipi_all.h> 61 #include <dev/scsipi/scsiconf.h> 62 #include <dev/scsipi/atapiconf.h> 63 64 #ifdef USSCANNER_DEBUG 65 #define DPRINTF(x) if (usscannerdebug) logprintf x 66 #define DPRINTFN(n,x) if (usscannerdebug>(n)) logprintf x 67 int usscannerdebug = 0; 68 #else 69 #define DPRINTF(x) 70 #define DPRINTFN(n,x) 71 #endif 72 73 74 #define USSCANNER_CONFIG_NO 1 75 #define USSCANNER_IFACE_IDX 0 76 77 #define USSCANNER_SCSIID_HOST 0x00 78 #define USSCANNER_SCSIID_DEVICE 0x01 79 80 #define USSCANNER_MAX_TRANSFER_SIZE MAXBSIZE 81 82 #define USSCANNER_TIMEOUT 2000 83 84 Static struct scsipi_device usscanner_dev = 85 { 86 NULL, /* Use default error handler */ 87 NULL, /* have a queue, served by this */ 88 NULL, /* have no async handler */ 89 NULL, /* Use default 'done' routine */ 90 }; 91 92 struct usscanner_softc { 93 USBBASEDEVICE sc_dev; 94 usbd_device_handle sc_udev; 95 usbd_interface_handle sc_iface; 96 97 int sc_in_addr; 98 usbd_pipe_handle sc_in_pipe; 99 100 int sc_intr_addr; 101 usbd_pipe_handle sc_intr_pipe; 102 usbd_xfer_handle sc_intr_xfer; 103 u_char sc_status; 104 105 int sc_out_addr; 106 usbd_pipe_handle sc_out_pipe; 107 108 usbd_xfer_handle sc_cmd_xfer; 109 void *sc_cmd_buffer; 110 usbd_xfer_handle sc_data_xfer; 111 void *sc_data_buffer; 112 113 int sc_state; 114 #define UAS_IDLE 0 115 #define UAS_CMD 1 116 #define UAS_DATA 2 117 #define UAS_SENSECMD 3 118 #define UAS_SENSEDATA 4 119 #define UAS_STATUS 5 120 121 struct scsipi_xfer *sc_xs; 122 123 device_ptr_t sc_child; /* child device, for detach */ 124 125 struct scsipi_link sc_link; 126 struct atapi_adapter sc_atapi_adapter; 127 #define sc_adapter sc_atapi_adapter._generic 128 129 int sc_refcnt; 130 char sc_dying; 131 }; 132 133 134 Static void usscanner_cleanup(struct usscanner_softc *sc); 135 Static int usscanner_scsipi_cmd(struct scsipi_xfer *xs); 136 Static void usscanner_scsipi_minphys(struct buf *bp); 137 Static void usscanner_done(struct usscanner_softc *sc); 138 Static void usscanner_sense(struct usscanner_softc *sc); 139 typedef void callback(usbd_xfer_handle, usbd_private_handle, usbd_status); 140 Static callback usscanner_intr_cb; 141 Static callback usscanner_cmd_cb; 142 Static callback usscanner_data_cb; 143 Static callback usscanner_sensecmd_cb; 144 Static callback usscanner_sensedata_cb; 145 146 USB_DECLARE_DRIVER(usscanner); 147 148 USB_MATCH(usscanner) 149 { 150 USB_MATCH_START(usscanner, uaa); 151 152 DPRINTFN(50,("usscanner_match\n")); 153 154 if (uaa->iface != NULL) 155 return (UMATCH_NONE); 156 157 if (uaa->vendor == USB_VENDOR_HP && 158 uaa->product == USB_PRODUCT_HP_5300C) 159 return (UMATCH_VENDOR_PRODUCT); 160 else 161 return (UMATCH_NONE); 162 } 163 164 USB_ATTACH(usscanner) 165 { 166 USB_ATTACH_START(usscanner, sc, uaa); 167 usbd_device_handle dev = uaa->device; 168 usbd_interface_handle iface; 169 char devinfo[1024]; 170 usbd_status err; 171 usb_endpoint_descriptor_t *ed; 172 u_int8_t epcount; 173 int i; 174 175 DPRINTFN(10,("usscanner_attach: sc=%p\n", sc)); 176 177 usbd_devinfo(dev, 0, devinfo); 178 USB_ATTACH_SETUP; 179 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); 180 181 err = usbd_set_config_no(dev, USSCANNER_CONFIG_NO, 1); 182 if (err) { 183 printf("%s: setting config no failed\n", 184 USBDEVNAME(sc->sc_dev)); 185 USB_ATTACH_ERROR_RETURN; 186 } 187 188 err = usbd_device2interface_handle(dev, USSCANNER_IFACE_IDX, &iface); 189 if (err) { 190 printf("%s: getting interface handle failed\n", 191 USBDEVNAME(sc->sc_dev)); 192 USB_ATTACH_ERROR_RETURN; 193 } 194 195 sc->sc_udev = dev; 196 sc->sc_iface = iface; 197 198 epcount = 0; 199 (void)usbd_endpoint_count(iface, &epcount); 200 201 sc->sc_in_addr = -1; 202 sc->sc_intr_addr = -1; 203 sc->sc_out_addr = -1; 204 for (i = 0; i < epcount; i++) { 205 ed = usbd_interface2endpoint_descriptor(iface, i); 206 if (ed == NULL) { 207 printf("%s: couldn't get ep %d\n", 208 USBDEVNAME(sc->sc_dev), i); 209 USB_ATTACH_ERROR_RETURN; 210 } 211 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 212 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 213 sc->sc_in_addr = ed->bEndpointAddress; 214 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 215 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 216 sc->sc_intr_addr = ed->bEndpointAddress; 217 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 218 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 219 sc->sc_out_addr = ed->bEndpointAddress; 220 } 221 } 222 if (sc->sc_in_addr == -1 || sc->sc_intr_addr == -1 || 223 sc->sc_out_addr == -1) { 224 printf("%s: missing endpoint\n", USBDEVNAME(sc->sc_dev)); 225 USB_ATTACH_ERROR_RETURN; 226 } 227 228 err = usbd_open_pipe(sc->sc_iface, sc->sc_in_addr, 229 USBD_EXCLUSIVE_USE, &sc->sc_in_pipe); 230 if (err) { 231 printf("%s: open in pipe failed, err=%d\n", 232 USBDEVNAME(sc->sc_dev), err); 233 USB_ATTACH_ERROR_RETURN; 234 } 235 236 /* The interrupt endpoint must be opened as a normal pipe. */ 237 err = usbd_open_pipe(sc->sc_iface, sc->sc_intr_addr, 238 USBD_EXCLUSIVE_USE, &sc->sc_intr_pipe); 239 240 if (err) { 241 printf("%s: open intr pipe failed, err=%d\n", 242 USBDEVNAME(sc->sc_dev), err); 243 usscanner_cleanup(sc); 244 USB_ATTACH_ERROR_RETURN; 245 } 246 err = usbd_open_pipe(sc->sc_iface, sc->sc_out_addr, 247 USBD_EXCLUSIVE_USE, &sc->sc_out_pipe); 248 if (err) { 249 printf("%s: open out pipe failed, err=%d\n", 250 USBDEVNAME(sc->sc_dev), err); 251 usscanner_cleanup(sc); 252 USB_ATTACH_ERROR_RETURN; 253 } 254 255 sc->sc_cmd_xfer = usbd_alloc_xfer(uaa->device); 256 if (sc->sc_cmd_xfer == NULL) { 257 printf("%s: alloc cmd xfer failed, err=%d\n", 258 USBDEVNAME(sc->sc_dev), err); 259 usscanner_cleanup(sc); 260 USB_ATTACH_ERROR_RETURN; 261 } 262 263 /* XXX too big */ 264 sc->sc_cmd_buffer = usbd_alloc_buffer(sc->sc_cmd_xfer, 265 USSCANNER_MAX_TRANSFER_SIZE); 266 if (sc->sc_cmd_buffer == NULL) { 267 printf("%s: alloc cmd buffer failed, err=%d\n", 268 USBDEVNAME(sc->sc_dev), err); 269 usscanner_cleanup(sc); 270 USB_ATTACH_ERROR_RETURN; 271 } 272 273 sc->sc_intr_xfer = usbd_alloc_xfer (uaa->device); 274 if (sc->sc_intr_xfer == NULL) { 275 printf("%s: alloc intr xfer failed, err=%d\n", 276 USBDEVNAME(sc->sc_dev), err); 277 usscanner_cleanup(sc); 278 USB_ATTACH_ERROR_RETURN; 279 } 280 281 sc->sc_data_xfer = usbd_alloc_xfer(uaa->device); 282 if (sc->sc_data_xfer == NULL) { 283 printf("%s: alloc data xfer failed, err=%d\n", 284 USBDEVNAME(sc->sc_dev), err); 285 usscanner_cleanup(sc); 286 USB_ATTACH_ERROR_RETURN; 287 } 288 sc->sc_data_buffer = usbd_alloc_buffer(sc->sc_data_xfer, 289 USSCANNER_MAX_TRANSFER_SIZE); 290 if (sc->sc_data_buffer == NULL) { 291 printf("%s: alloc data buffer failed, err=%d\n", 292 USBDEVNAME(sc->sc_dev), err); 293 usscanner_cleanup(sc); 294 USB_ATTACH_ERROR_RETURN; 295 } 296 297 /* 298 * Fill in the adapter. 299 */ 300 sc->sc_adapter.scsipi_cmd = usscanner_scsipi_cmd; 301 sc->sc_adapter.scsipi_minphys = usscanner_scsipi_minphys; 302 303 /* 304 * fill in the prototype scsipi_link. 305 */ 306 sc->sc_link.type = BUS_SCSI; 307 sc->sc_link.scsipi_scsi.channel = SCSI_CHANNEL_ONLY_ONE; 308 sc->sc_link.adapter_softc = sc; 309 sc->sc_link.scsipi_scsi.adapter_target = USSCANNER_SCSIID_HOST; 310 sc->sc_link.adapter = &sc->sc_adapter; 311 sc->sc_link.device = &usscanner_dev; 312 sc->sc_link.openings = 1; 313 sc->sc_link.scsipi_scsi.max_target = USSCANNER_SCSIID_DEVICE; 314 sc->sc_link.scsipi_scsi.max_lun = 0; 315 316 sc->sc_child = config_found(&sc->sc_dev, &sc->sc_link, scsiprint); 317 318 DPRINTFN(10, ("usscanner_attach: %p\n", sc->sc_udev)); 319 320 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 321 USBDEV(sc->sc_dev)); 322 323 USB_ATTACH_SUCCESS_RETURN; 324 } 325 326 USB_DETACH(usscanner) 327 { 328 USB_DETACH_START(usscanner, sc); 329 int rv, s; 330 331 DPRINTF(("usscanner_detach: sc=%p flags=%d\n", sc, flags)); 332 333 sc->sc_dying = 1; 334 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 335 if (sc->sc_in_pipe != NULL) 336 usbd_abort_pipe(sc->sc_in_pipe); 337 if (sc->sc_intr_pipe != NULL) 338 usbd_abort_pipe(sc->sc_intr_pipe); 339 if (sc->sc_out_pipe != NULL) 340 usbd_abort_pipe(sc->sc_out_pipe); 341 342 s = splusb(); 343 if (--sc->sc_refcnt >= 0) { 344 /* Wait for processes to go away. */ 345 usb_detach_wait(USBDEV(sc->sc_dev)); 346 } 347 splx(s); 348 349 if (sc->sc_child != NULL) 350 rv = config_detach(sc->sc_child, flags); 351 else 352 rv = 0; 353 354 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 355 USBDEV(sc->sc_dev)); 356 357 return (rv); 358 } 359 360 Static void 361 usscanner_cleanup(struct usscanner_softc *sc) 362 { 363 if (sc->sc_in_pipe != NULL) { 364 usbd_close_pipe(sc->sc_in_pipe); 365 sc->sc_in_pipe = NULL; 366 } 367 if (sc->sc_intr_pipe != NULL) { 368 usbd_close_pipe(sc->sc_intr_pipe); 369 sc->sc_intr_pipe = NULL; 370 } 371 if (sc->sc_out_pipe != NULL) { 372 usbd_close_pipe(sc->sc_out_pipe); 373 sc->sc_out_pipe = NULL; 374 } 375 if (sc->sc_cmd_xfer != NULL) { 376 usbd_free_xfer(sc->sc_cmd_xfer); 377 sc->sc_cmd_xfer = NULL; 378 } 379 if (sc->sc_data_xfer != NULL) { 380 usbd_free_xfer(sc->sc_data_xfer); 381 sc->sc_data_xfer = NULL; 382 } 383 } 384 385 int 386 usscanner_activate(device_ptr_t self, enum devact act) 387 { 388 struct usscanner_softc *sc = (struct usscanner_softc *)self; 389 390 switch (act) { 391 case DVACT_ACTIVATE: 392 return (EOPNOTSUPP); 393 break; 394 395 case DVACT_DEACTIVATE: 396 sc->sc_dying = 1; 397 break; 398 } 399 return (0); 400 } 401 402 Static void 403 usscanner_scsipi_minphys(struct buf *bp) 404 { 405 if (bp->b_bcount > USSCANNER_MAX_TRANSFER_SIZE) 406 bp->b_bcount = USSCANNER_MAX_TRANSFER_SIZE; 407 minphys(bp); 408 } 409 410 Static void 411 usscanner_sense(struct usscanner_softc *sc) 412 { 413 struct scsipi_xfer *xs = sc->sc_xs; 414 struct scsipi_link *sc_link = xs->sc_link; 415 struct scsipi_sense sense_cmd; 416 usbd_status err; 417 418 /* fetch sense data */ 419 memset(&sense_cmd, 0, sizeof(sense_cmd)); 420 sense_cmd.opcode = REQUEST_SENSE; 421 sense_cmd.byte2 = sc_link->scsipi_scsi.lun << SCSI_CMD_LUN_SHIFT; 422 sense_cmd.length = sizeof xs->sense; 423 424 sc->sc_state = UAS_SENSECMD; 425 memcpy(sc->sc_cmd_buffer, &sense_cmd, sizeof sense_cmd); 426 usbd_setup_xfer(sc->sc_cmd_xfer, sc->sc_out_pipe, sc, sc->sc_cmd_buffer, 427 sizeof sense_cmd, USBD_NO_COPY, USSCANNER_TIMEOUT, 428 usscanner_sensecmd_cb); 429 err = usbd_transfer(sc->sc_cmd_xfer); 430 if (err == USBD_IN_PROGRESS) 431 return; 432 433 xs->error = XS_DRIVER_STUFFUP; 434 usscanner_done(sc); 435 } 436 437 Static void 438 usscanner_intr_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 439 usbd_status status) 440 { 441 struct usscanner_softc *sc = priv; 442 int s; 443 444 DPRINTFN(10, ("usscanner_data_cb status=%d\n", status)); 445 446 #ifdef USSCANNER_DEBUG 447 if (sc->sc_state != UAS_STATUS) { 448 printf("%s: !UAS_STATUS\n", USBDEVNAME(sc->sc_dev)); 449 } 450 #endif 451 452 sc->sc_state = UAS_IDLE; 453 454 sc->sc_xs->xs_status |= XS_STS_DONE; 455 s = splbio(); 456 scsipi_done(sc->sc_xs); 457 splx(s); 458 } 459 460 Static void 461 usscanner_data_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 462 usbd_status status) 463 { 464 struct usscanner_softc *sc = priv; 465 struct scsipi_xfer *xs = sc->sc_xs; 466 u_int32_t len; 467 468 DPRINTFN(10, ("usscanner_data_cb status=%d\n", status)); 469 470 #ifdef USSCANNER_DEBUG 471 if (sc->sc_state != UAS_DATA) { 472 printf("%s: !UAS_DATA\n", USBDEVNAME(sc->sc_dev)); 473 } 474 #endif 475 476 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 477 478 xs->resid = xs->datalen - len; 479 480 switch (status) { 481 case USBD_NORMAL_COMPLETION: 482 if (xs->xs_control & XS_CTL_DATA_IN) 483 memcpy(xs->data, sc->sc_data_buffer, len); 484 xs->error = XS_NOERROR; 485 break; 486 case USBD_TIMEOUT: 487 xs->error = XS_TIMEOUT; 488 break; 489 case USBD_CANCELLED: 490 if (xs->error == XS_SENSE) { 491 usscanner_sense(sc); 492 return; 493 } 494 break; 495 default: 496 xs->error = XS_DRIVER_STUFFUP; /* XXX ? */ 497 break; 498 } 499 usscanner_done(sc); 500 } 501 502 Static void 503 usscanner_sensedata_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 504 usbd_status status) 505 { 506 struct usscanner_softc *sc = priv; 507 struct scsipi_xfer *xs = sc->sc_xs; 508 u_int32_t len; 509 510 DPRINTFN(10, ("usscanner_sensedata_cb status=%d\n", status)); 511 512 #ifdef USSCANNER_DEBUG 513 if (sc->sc_state != UAS_SENSEDATA) { 514 printf("%s: !UAS_SENSEDATA\n", USBDEVNAME(sc->sc_dev)); 515 } 516 #endif 517 518 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 519 520 switch (status) { 521 case USBD_NORMAL_COMPLETION: 522 memcpy(&xs->sense, sc->sc_data_buffer, len); 523 if (len < sizeof xs->sense) 524 xs->error = XS_SHORTSENSE; 525 break; 526 case USBD_TIMEOUT: 527 xs->error = XS_TIMEOUT; 528 break; 529 case USBD_CANCELLED: 530 xs->error = XS_RESET; 531 break; 532 default: 533 xs->error = XS_DRIVER_STUFFUP; /* XXX ? */ 534 break; 535 } 536 usscanner_done(sc); 537 } 538 539 Static void 540 usscanner_done(struct usscanner_softc *sc) 541 { 542 struct scsipi_xfer *xs = sc->sc_xs; 543 usbd_status err; 544 545 DPRINTFN(10,("usscanner_done: error=%d\n", sc->sc_xs->error)); 546 547 sc->sc_state = UAS_STATUS; 548 usbd_setup_xfer(sc->sc_intr_xfer, sc->sc_intr_pipe, sc, &sc->sc_status, 549 1, USBD_SHORT_XFER_OK | USBD_NO_COPY, 550 USSCANNER_TIMEOUT, usscanner_intr_cb); 551 err = usbd_transfer(sc->sc_intr_xfer); 552 if (err == USBD_IN_PROGRESS) 553 return; 554 xs->error = XS_DRIVER_STUFFUP; 555 } 556 557 Static void 558 usscanner_sensecmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 559 usbd_status status) 560 { 561 struct usscanner_softc *sc = priv; 562 struct scsipi_xfer *xs = sc->sc_xs; 563 usbd_status err; 564 565 DPRINTFN(10, ("usscanner_sensecmd_cb status=%d\n", status)); 566 567 #ifdef USSCANNER_DEBUG 568 if (usscannerdebug > 15) 569 xs->sc_link->flags |= DEBUGLEVEL; 570 571 if (sc->sc_state != UAS_SENSECMD) { 572 printf("%s: !UAS_SENSECMD\n", USBDEVNAME(sc->sc_dev)); 573 xs->error = XS_DRIVER_STUFFUP; 574 goto done; 575 } 576 #endif 577 578 switch (status) { 579 case USBD_NORMAL_COMPLETION: 580 break; 581 case USBD_TIMEOUT: 582 xs->error = XS_TIMEOUT; 583 goto done; 584 default: 585 xs->error = XS_DRIVER_STUFFUP; /* XXX ? */ 586 goto done; 587 } 588 589 sc->sc_state = UAS_SENSEDATA; 590 usbd_setup_xfer(sc->sc_data_xfer, sc->sc_in_pipe, sc, 591 sc->sc_data_buffer, 592 sizeof xs->sense, USBD_SHORT_XFER_OK | USBD_NO_COPY, 593 USSCANNER_TIMEOUT, usscanner_sensedata_cb); 594 err = usbd_transfer(sc->sc_data_xfer); 595 if (err == USBD_IN_PROGRESS) 596 return; 597 xs->error = XS_DRIVER_STUFFUP; 598 done: 599 usscanner_done(sc); 600 } 601 602 Static void 603 usscanner_cmd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 604 usbd_status status) 605 { 606 struct usscanner_softc *sc = priv; 607 struct scsipi_xfer *xs = sc->sc_xs; 608 usbd_pipe_handle pipe; 609 usbd_status err; 610 611 DPRINTFN(10, ("usscanner_cmd_cb status=%d\n", status)); 612 613 #ifdef USSCANNER_DEBUG 614 if (usscannerdebug > 15) 615 xs->sc_link->flags |= DEBUGLEVEL; 616 617 if (sc->sc_state != UAS_CMD) { 618 printf("%s: !UAS_CMD\n", USBDEVNAME(sc->sc_dev)); 619 xs->error = XS_DRIVER_STUFFUP; 620 goto done; 621 } 622 #endif 623 624 switch (status) { 625 case USBD_NORMAL_COMPLETION: 626 break; 627 case USBD_TIMEOUT: 628 xs->error = XS_TIMEOUT; 629 goto done; 630 case USBD_CANCELLED: 631 goto done; 632 default: 633 xs->error = XS_DRIVER_STUFFUP; /* XXX ? */ 634 goto done; 635 } 636 637 if (xs->datalen == 0) { 638 DPRINTFN(4, ("usscanner_cmd_cb: no data phase\n")); 639 xs->error = XS_NOERROR; 640 goto done; 641 } 642 643 if (xs->xs_control & XS_CTL_DATA_IN) { 644 DPRINTFN(4, ("usscanner_cmd_cb: data in len=%d\n", 645 xs->datalen)); 646 pipe = sc->sc_in_pipe; 647 } else { 648 DPRINTFN(4, ("usscanner_cmd_cb: data out len=%d\n", 649 xs->datalen)); 650 memcpy(sc->sc_data_buffer, xs->data, xs->datalen); 651 pipe = sc->sc_out_pipe; 652 } 653 sc->sc_state = UAS_DATA; 654 usbd_setup_xfer(sc->sc_data_xfer, pipe, sc, sc->sc_data_buffer, 655 xs->datalen, USBD_SHORT_XFER_OK | USBD_NO_COPY, 656 xs->timeout, usscanner_data_cb); 657 err = usbd_transfer(sc->sc_data_xfer); 658 if (err == USBD_IN_PROGRESS) 659 return; 660 xs->error = XS_DRIVER_STUFFUP; 661 662 done: 663 usscanner_done(sc); 664 } 665 666 Static int 667 usscanner_scsipi_cmd(struct scsipi_xfer *xs) 668 { 669 struct scsipi_link *sc_link = xs->sc_link; 670 struct usscanner_softc *sc = sc_link->adapter_softc; 671 usbd_status err; 672 673 DPRINTFN(8, ("%s: usscanner_scsi_cmd: %d:%d " 674 "xs=%p cmd=0x%02x datalen=%d (quirks=0x%x, poll=%d)\n", 675 USBDEVNAME(sc->sc_dev), 676 sc_link->scsipi_scsi.target, sc_link->scsipi_scsi.lun, 677 xs, xs->cmd->opcode, xs->datalen, 678 sc_link->quirks, xs->xs_control & XS_CTL_POLL)); 679 680 if (sc->sc_dying) { 681 xs->error = XS_DRIVER_STUFFUP; 682 goto done; 683 } 684 685 #ifdef USSCANNER_DEBUG 686 if (sc_link->scsipi_scsi.target != USSCANNER_SCSIID_DEVICE) { 687 DPRINTF(("%s: wrong SCSI ID %d\n", USBDEVNAME(sc->sc_dev), 688 sc_link->scsipi_scsi.target)); 689 xs->error = XS_DRIVER_STUFFUP; 690 goto done; 691 } 692 if (sc->sc_state != UAS_IDLE) { 693 printf("%s: !UAS_IDLE\n", USBDEVNAME(sc->sc_dev)); 694 xs->error = XS_DRIVER_STUFFUP; 695 goto done; 696 } 697 #endif 698 699 if (xs->datalen > USSCANNER_MAX_TRANSFER_SIZE) { 700 printf("umass_cmd: large datalen, %d\n", xs->datalen); 701 xs->error = XS_DRIVER_STUFFUP; 702 goto done; 703 } 704 705 DPRINTFN(4, ("usscanner_scsi_cmd: async cmdlen=%d datalen=%d\n", 706 xs->cmdlen, xs->datalen)); 707 sc->sc_state = UAS_CMD; 708 sc->sc_xs = xs; 709 memcpy(sc->sc_cmd_buffer, xs->cmd, xs->cmdlen); 710 usbd_setup_xfer(sc->sc_cmd_xfer, sc->sc_out_pipe, sc, sc->sc_cmd_buffer, 711 xs->cmdlen, USBD_NO_COPY, USSCANNER_TIMEOUT, usscanner_cmd_cb); 712 err = usbd_transfer(sc->sc_cmd_xfer); 713 if (err != USBD_IN_PROGRESS) { 714 xs->error = XS_DRIVER_STUFFUP; 715 goto done; 716 } 717 718 return (SUCCESSFULLY_QUEUED); 719 720 721 done: 722 sc->sc_state = UAS_IDLE; 723 xs->xs_status |= XS_STS_DONE; 724 scsipi_done(xs); 725 if (xs->xs_control & XS_CTL_POLL) 726 return (COMPLETE); 727 else 728 return (SUCCESSFULLY_QUEUED); 729 } 730
Indexes created Tue Sep 30 11:09:46 GMT 2025