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