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