xs 625 compat/ibcs2/ibcs2_exec.c struct xseg *xs;
xs 628 compat/ibcs2/ibcs2_exec.c if (xep->xe_segsize > 16 * sizeof(*xs))
xs 630 compat/ibcs2/ibcs2_exec.c xs = (struct xseg *)malloc(xep->xe_segsize, M_TEMP, M_WAITOK);
xs 631 compat/ibcs2/ibcs2_exec.c error = vn_rdwr(UIO_READ, epp->ep_vp, (caddr_t)xs,
xs 637 compat/ibcs2/ibcs2_exec.c free(xs, M_TEMP);
xs 641 compat/ibcs2/ibcs2_exec.c for (nseg = xep->xe_segsize / sizeof(*xs), i = 0; i < nseg; i++) {
xs 642 compat/ibcs2/ibcs2_exec.c switch (xs[i].xs_type) {
xs 646 compat/ibcs2/ibcs2_exec.c xs[i].xs_rbase, xs[i].xs_psize,
xs 647 compat/ibcs2/ibcs2_exec.c xs[i].xs_vsize, xs[i].xs_filpos));
xs 649 compat/ibcs2/ibcs2_exec.c epp->ep_taddr = xs[i].xs_rbase; /* XXX - align ??? */
xs 650 compat/ibcs2/ibcs2_exec.c epp->ep_tsize = xs[i].xs_vsize;
xs 654 compat/ibcs2/ibcs2_exec.c xs[i].xs_filpos));
xs 657 compat/ibcs2/ibcs2_exec.c epp->ep_vp, xs[i].xs_filpos,
xs 664 compat/ibcs2/ibcs2_exec.c xs[i].xs_rbase, xs[i].xs_psize,
xs 665 compat/ibcs2/ibcs2_exec.c xs[i].xs_vsize, xs[i].xs_filpos));
xs 667 compat/ibcs2/ibcs2_exec.c epp->ep_daddr = xs[i].xs_rbase; /* XXX - align ??? */
xs 668 compat/ibcs2/ibcs2_exec.c epp->ep_dsize = xs[i].xs_vsize;
xs 671 compat/ibcs2/ibcs2_exec.c epp->ep_daddr, xs[i].xs_psize,
xs 672 compat/ibcs2/ibcs2_exec.c xs[i].xs_filpos));
xs 674 compat/ibcs2/ibcs2_exec.c xs[i].xs_psize, epp->ep_daddr,
xs 675 compat/ibcs2/ibcs2_exec.c epp->ep_vp, xs[i].xs_filpos,
xs 679 compat/ibcs2/ibcs2_exec.c baddr = round_page(epp->ep_daddr + xs[i].xs_psize);
xs 704 compat/ibcs2/ibcs2_exec.c free(xs, M_TEMP);
xs 264 dev/ata/atascsi.c atascsi_cmd(struct scsi_xfer *xs)
xs 266 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 271 dev/ata/atascsi.c return (atascsi_stuffup(xs));
xs 275 dev/ata/atascsi.c return (atascsi_disk_cmd(xs));
xs 277 dev/ata/atascsi.c return (atascsi_atapi_cmd(xs));
xs 281 dev/ata/atascsi.c return (atascsi_stuffup(xs));
xs 286 dev/ata/atascsi.c atascsi_disk_cmd(struct scsi_xfer *xs)
xs 288 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 299 dev/ata/atascsi.c switch (xs->cmd->opcode) {
xs 311 dev/ata/atascsi.c return (atascsi_disk_sync(xs));
xs 313 dev/ata/atascsi.c return (atascsi_disk_sense(xs));
xs 315 dev/ata/atascsi.c return (atascsi_disk_inq(xs));
xs 317 dev/ata/atascsi.c return (atascsi_disk_capacity(xs));
xs 325 dev/ata/atascsi.c return (atascsi_stuffup(xs));
xs 329 dev/ata/atascsi.c xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
xs 335 dev/ata/atascsi.c if (xs->cmdlen == 6) {
xs 336 dev/ata/atascsi.c rw = (struct scsi_rw *)xs->cmd;
xs 340 dev/ata/atascsi.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 352 dev/ata/atascsi.c if (ap->ap_ncqdepth && !(xs->flags & SCSI_POLL)) {
xs 382 dev/ata/atascsi.c xa->data = xs->data;
xs 383 dev/ata/atascsi.c xa->datalen = xs->datalen;
xs 385 dev/ata/atascsi.c xa->timeout = xs->timeout;
xs 386 dev/ata/atascsi.c xa->atascsi_private = xs;
xs 387 dev/ata/atascsi.c if (xs->flags & SCSI_POLL)
xs 402 dev/ata/atascsi.c struct scsi_xfer *xs = xa->atascsi_private;
xs 406 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 410 dev/ata/atascsi.c xs->error = XS_DRIVER_STUFFUP;
xs 413 dev/ata/atascsi.c xs->error = XS_TIMEOUT;
xs 420 dev/ata/atascsi.c xs->resid = xa->resid;
xs 423 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 424 dev/ata/atascsi.c scsi_done(xs);
xs 428 dev/ata/atascsi.c atascsi_disk_inq(struct scsi_xfer *xs)
xs 430 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 435 dev/ata/atascsi.c xa = ata_setup_identify(ap, xs->flags & SCSI_NOSLEEP);
xs 440 dev/ata/atascsi.c xa->timeout = xs->timeout;
xs 441 dev/ata/atascsi.c xa->atascsi_private = xs;
xs 442 dev/ata/atascsi.c if (xs->flags & SCSI_POLL)
xs 451 dev/ata/atascsi.c struct scsi_xfer *xs = xa->atascsi_private;
xs 452 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 473 dev/ata/atascsi.c bcopy(&inq, xs->data, MIN(sizeof(inq), xs->datalen));
xs 474 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 481 dev/ata/atascsi.c xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
xs 490 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 491 dev/ata/atascsi.c scsi_done(xs);
xs 532 dev/ata/atascsi.c atascsi_disk_sync(struct scsi_xfer *xs)
xs 534 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 541 dev/ata/atascsi.c xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
xs 550 dev/ata/atascsi.c xa->timeout = (xs->timeout < 45000) ? 45000 : xs->timeout;
xs 551 dev/ata/atascsi.c xa->atascsi_private = xs;
xs 552 dev/ata/atascsi.c if (xs->flags & SCSI_POLL)
xs 565 dev/ata/atascsi.c struct scsi_xfer *xs = xa->atascsi_private;
xs 569 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 576 dev/ata/atascsi.c xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
xs 587 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 588 dev/ata/atascsi.c scsi_done(xs);
xs 592 dev/ata/atascsi.c atascsi_disk_capacity(struct scsi_xfer *xs)
xs 594 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 599 dev/ata/atascsi.c xa = ata_setup_identify(ap, xs->flags & SCSI_NOSLEEP);
xs 604 dev/ata/atascsi.c xa->timeout = xs->timeout;
xs 605 dev/ata/atascsi.c xa->atascsi_private = xs;
xs 606 dev/ata/atascsi.c if (xs->flags & SCSI_POLL)
xs 615 dev/ata/atascsi.c struct scsi_xfer *xs = xa->atascsi_private;
xs 645 dev/ata/atascsi.c bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen));
xs 646 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 652 dev/ata/atascsi.c xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
xs 661 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 662 dev/ata/atascsi.c scsi_done(xs);
xs 666 dev/ata/atascsi.c atascsi_disk_sense(struct scsi_xfer *xs)
xs 668 dev/ata/atascsi.c struct scsi_sense_data *sd = (struct scsi_sense_data *)xs->data;
xs 671 dev/ata/atascsi.c bzero(xs->data, xs->datalen);
xs 676 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 677 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 680 dev/ata/atascsi.c scsi_done(xs);
xs 686 dev/ata/atascsi.c atascsi_atapi_cmd(struct scsi_xfer *xs)
xs 688 dev/ata/atascsi.c struct scsi_link *link = xs->sc_link;
xs 696 dev/ata/atascsi.c xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
xs 701 dev/ata/atascsi.c switch (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 712 dev/ata/atascsi.c xa->data = xs->data;
xs 713 dev/ata/atascsi.c xa->datalen = xs->datalen;
xs 715 dev/ata/atascsi.c xa->timeout = xs->timeout;
xs 716 dev/ata/atascsi.c xa->atascsi_private = xs;
xs 717 dev/ata/atascsi.c if (xs->flags & SCSI_POLL)
xs 731 dev/ata/atascsi.c memcpy(xa->packetcmd, xs->cmd, xs->cmdlen);
xs 739 dev/ata/atascsi.c struct scsi_xfer *xs = xa->atascsi_private;
xs 740 dev/ata/atascsi.c struct scsi_sense_data *sd = &xs->sense;
xs 744 dev/ata/atascsi.c xs->error = XS_NOERROR;
xs 756 dev/ata/atascsi.c xs->error = XS_SENSE;
xs 760 dev/ata/atascsi.c xs->error = XS_TIMEOUT;
xs 767 dev/ata/atascsi.c xs->resid = xa->resid;
xs 770 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 771 dev/ata/atascsi.c scsi_done(xs);
xs 775 dev/ata/atascsi.c atascsi_stuffup(struct scsi_xfer *xs)
xs 779 dev/ata/atascsi.c xs->error = XS_DRIVER_STUFFUP;
xs 780 dev/ata/atascsi.c xs->flags |= ITSDONE;
xs 783 dev/ata/atascsi.c scsi_done(xs);
xs 253 dev/eisa/aha1742.c struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 361 dev/eisa/aha1742.c bus_space_write_1(iot, ioh, ATTN, opcode | ecb->xs->sc_link->target);
xs 368 dev/eisa/aha1742.c ahb_poll(sc, xs, count)
xs 370 dev/eisa/aha1742.c struct scsi_xfer *xs;
xs 383 dev/eisa/aha1742.c if (xs->flags & ITSDONE)
xs 615 dev/eisa/aha1742.c show_scsi_cmd(ecb->xs);
xs 619 dev/eisa/aha1742.c timeout_del(&ecb->xs->stimeout);
xs 640 dev/eisa/aha1742.c struct scsi_xfer *xs = ecb->xs;
xs 642 dev/eisa/aha1742.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("ahb_done\n"));
xs 649 dev/eisa/aha1742.c xs->error = XS_DRIVER_STUFFUP;
xs 652 dev/eisa/aha1742.c if (xs->error == XS_NOERROR) {
xs 661 dev/eisa/aha1742.c xs->error = XS_DRIVER_STUFFUP;
xs 664 dev/eisa/aha1742.c xs->error = XS_SELTIMEOUT;
xs 669 dev/eisa/aha1742.c xs->error = XS_DRIVER_STUFFUP;
xs 675 dev/eisa/aha1742.c s2 = &xs->sense;
xs 677 dev/eisa/aha1742.c xs->error = XS_SENSE;
xs 680 dev/eisa/aha1742.c xs->error = XS_BUSY;
xs 685 dev/eisa/aha1742.c xs->error = XS_DRIVER_STUFFUP;
xs 688 dev/eisa/aha1742.c xs->resid = 0;
xs 691 dev/eisa/aha1742.c xs->flags |= ITSDONE;
xs 692 dev/eisa/aha1742.c ahb_free_ecb(sc, ecb, xs->flags);
xs 693 dev/eisa/aha1742.c scsi_done(xs);
xs 942 dev/eisa/aha1742.c ahb_scsi_cmd(xs)
xs 943 dev/eisa/aha1742.c struct scsi_xfer *xs;
xs 945 dev/eisa/aha1742.c struct scsi_link *sc_link = xs->sc_link;
xs 963 dev/eisa/aha1742.c flags = xs->flags;
xs 966 dev/eisa/aha1742.c xs->flags &= ~ITSDONE;
xs 971 dev/eisa/aha1742.c ecb->xs = xs;
xs 972 dev/eisa/aha1742.c timeout_set(&ecb->xs->stimeout, ahb_timeout, ecb);
xs 992 dev/eisa/aha1742.c timeout_add(&ecb->xs->stimeout, (xs->timeout * hz) / 1000);
xs 1001 dev/eisa/aha1742.c if (ahb_poll(sc, xs, xs->timeout))
xs 1011 dev/eisa/aha1742.c if (xs->datalen)
xs 1014 dev/eisa/aha1742.c ecb->scsi_cmd_length = xs->cmdlen;
xs 1021 dev/eisa/aha1742.c if (xs->datalen && (flags & SCSI_RESET) == 0) {
xs 1027 dev/eisa/aha1742.c iovp = ((struct uio *) xs->data)->uio_iov;
xs 1028 dev/eisa/aha1742.c datalen = ((struct uio *) xs->data)->uio_iovcnt;
xs 1029 dev/eisa/aha1742.c xs->datalen = 0;
xs 1033 dev/eisa/aha1742.c xs->datalen += iovp->iov_len;
xs 1049 dev/eisa/aha1742.c ("%d @0x%x:- ", xs->datalen, xs->data));
xs 1050 dev/eisa/aha1742.c datalen = xs->datalen;
xs 1051 dev/eisa/aha1742.c thiskv = (long) xs->data;
xs 1103 dev/eisa/aha1742.c xs->error = XS_DRIVER_STUFFUP;
xs 1117 dev/eisa/aha1742.c bcopy(xs->cmd, &ecb->scsi_cmd, ecb->scsi_cmd_length);
xs 1128 dev/eisa/aha1742.c timeout_add(&ecb->xs->stimeout, (xs->timeout * hz) / 1000);
xs 1137 dev/eisa/aha1742.c if (ahb_poll(sc, xs, xs->timeout)) {
xs 1139 dev/eisa/aha1742.c if (ahb_poll(sc, xs, 2000))
xs 1150 dev/eisa/aha1742.c struct scsi_xfer *xs = ecb->xs;
xs 1151 dev/eisa/aha1742.c struct scsi_link *sc_link = xs->sc_link;
xs 1162 dev/eisa/aha1742.c ecb->xs->retries = 0; /* I MEAN IT ! */
xs 1177 dev/eisa/aha1742.c ecb->xs->retries = 0; /* I MEAN IT ! */
xs 1182 dev/eisa/aha1742.c ecb->xs->error = XS_TIMEOUT;
xs 1186 dev/eisa/aha1742.c if ((xs->flags & SCSI_POLL) == 0)
xs 1187 dev/eisa/aha1742.c timeout_add(&ecb->xs->stimeout, 2 * hz);
xs 1203 dev/eisa/aha1742.c show_scsi_cmd(ecb->xs);
xs 249 dev/eisa/uha_eisa.c if ((mscp->xs->flags & SCSI_POLL) == 0)
xs 250 dev/eisa/uha_eisa.c timeout_add(&mscp->xs->stimeout, (mscp->timeout * hz) / 1000);
xs 254 dev/eisa/uha_eisa.c u24_poll(sc, xs, count)
xs 256 dev/eisa/uha_eisa.c struct scsi_xfer *xs;
xs 269 dev/eisa/uha_eisa.c if (xs->flags & ITSDONE)
xs 318 dev/eisa/uha_eisa.c timeout_del(&mscp->xs->stimeout);
xs 409 dev/i2o/ioprbs.c ioprbs_scsi_cmd(xs)
xs 410 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 412 dev/i2o/ioprbs.c struct scsi_link *link = xs->sc_link;
xs 424 dev/i2o/ioprbs.c if (xs != LIST_FIRST(&sc->sc_queue))
xs 425 dev/i2o/ioprbs.c ioprbs_enqueue(sc, xs, 0);
xs 427 dev/i2o/ioprbs.c while ((xs = ioprbs_dequeue(sc))) {
xs 428 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 432 dev/i2o/ioprbs.c switch (xs->cmd->opcode) {
xs 442 dev/i2o/ioprbs.c ioprbs_internal_cache_cmd(xs);
xs 443 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 444 dev/i2o/ioprbs.c scsi_done(xs);
xs 450 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 451 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 452 dev/i2o/ioprbs.c scsi_done(xs);
xs 458 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 459 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 460 dev/i2o/ioprbs.c scsi_done(xs);
xs 464 dev/i2o/ioprbs.c DPRINTF(("unknown opc %d ", xs->cmd->opcode));
xs 466 dev/i2o/ioprbs.c xs->error = XS_DRIVER_STUFFUP;
xs 467 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 468 dev/i2o/ioprbs.c scsi_done(xs);
xs 475 dev/i2o/ioprbs.c DPRINTF(("rw opc %d ", xs->cmd->opcode));
xs 477 dev/i2o/ioprbs.c if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 479 dev/i2o/ioprbs.c if (xs->cmdlen == 6) {
xs 480 dev/i2o/ioprbs.c rw = (struct scsi_rw *)xs->cmd;
xs 486 dev/i2o/ioprbs.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 501 dev/i2o/ioprbs.c xs->error = XS_DRIVER_STUFFUP;
xs 502 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 503 dev/i2o/ioprbs.c scsi_done(xs);
xs 508 dev/i2o/ioprbs.c ccb = ioprbs_get_ccb(sc, xs->flags);
xs 520 dev/i2o/ioprbs.c ccb->ic_xs = xs;
xs 521 dev/i2o/ioprbs.c ccb->ic_timeout = xs->timeout;
xs 526 dev/i2o/ioprbs.c if (xs->flags & SCSI_POLL) {
xs 534 dev/i2o/ioprbs.c xs->flags |= ITSDONE;
xs 535 dev/i2o/ioprbs.c scsi_done(xs);
xs 544 dev/i2o/ioprbs.c if (xs->flags & SCSI_POLL) {
xs 659 dev/i2o/ioprbs.c ioprbs_enqueue(sc, xs, infront)
xs 661 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 666 dev/i2o/ioprbs.c sc->sc_queuelast = xs;
xs 667 dev/i2o/ioprbs.c LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
xs 670 dev/i2o/ioprbs.c LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
xs 671 dev/i2o/ioprbs.c sc->sc_queuelast = xs;
xs 681 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 683 dev/i2o/ioprbs.c xs = LIST_FIRST(&sc->sc_queue);
xs 684 dev/i2o/ioprbs.c if (xs == NULL)
xs 686 dev/i2o/ioprbs.c LIST_REMOVE(xs, free_list);
xs 691 dev/i2o/ioprbs.c return (xs);
xs 695 dev/i2o/ioprbs.c ioprbs_copy_internal_data(xs, data, size)
xs 696 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 704 dev/i2o/ioprbs.c if (!xs->datalen)
xs 707 dev/i2o/ioprbs.c copy_cnt = MIN(size, xs->datalen);
xs 708 dev/i2o/ioprbs.c bcopy(data, xs->data, copy_cnt);
xs 714 dev/i2o/ioprbs.c ioprbs_internal_cache_cmd(xs)
xs 715 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 717 dev/i2o/ioprbs.c struct scsi_link *link = xs->sc_link;
xs 726 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 729 dev/i2o/ioprbs.c xs->error = XS_DRIVER_STUFFUP;
xs 733 dev/i2o/ioprbs.c switch (xs->cmd->opcode) {
xs 739 dev/i2o/ioprbs.c DPRINTF(("opc %d tgt %d ", xs->cmd->opcode, target));
xs 750 dev/i2o/ioprbs.c ioprbs_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
xs 766 dev/i2o/ioprbs.c ioprbs_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
xs 774 dev/i2o/ioprbs.c ioprbs_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
xs 779 dev/i2o/ioprbs.c xs->cmd->opcode, target));
xs 780 dev/i2o/ioprbs.c xs->error = XS_DRIVER_STUFFUP;
xs 784 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 855 dev/i2o/ioprbs.c struct scsi_xfer *xs;
xs 861 dev/i2o/ioprbs.c xs = ccb->ic_xs;
xs 863 dev/i2o/ioprbs.c timeout_del(&xs->stimeout);
xs 869 dev/i2o/ioprbs.c timeout_add(&xs->stimeout,
xs 875 dev/i2o/ioprbs.c if ((xs->flags & SCSI_POLL) == 0) {
xs 878 dev/i2o/ioprbs.c timeout_add(&xs->stimeout,
xs 888 dev/i2o/ioprbs.c struct scsi_xfer *xs = ccb->ic_xs;
xs 890 dev/i2o/ioprbs.c DPRINTF(("ioprbs_exec_ccb(%p, %p) ", xs, ccb));
xs 894 dev/i2o/ioprbs.c xs->error = XS_NOERROR;
xs 895 dev/i2o/ioprbs.c xs->resid = 0;
xs 906 dev/i2o/ioprbs.c struct scsi_xfer *xs = ccb->ic_xs;
xs 907 dev/i2o/ioprbs.c struct scsi_link *link = xs->sc_link;
xs 922 dev/i2o/ioprbs.c switch (xs->cmd->opcode) {
xs 925 dev/i2o/ioprbs.c if (xs->cmd->opcode == PREVENT_ALLOW) {
xs 958 dev/i2o/ioprbs.c rv = iop_msg_map_bio(iop, im, mb, xs->data,
xs 424 dev/i2o/iopsp.c iopsp_scsi_cmd(xs)
xs 425 dev/i2o/iopsp.c struct scsi_xfer *xs;
xs 427 dev/i2o/iopsp.c struct scsi_link *link = xs->sc_link;
xs 437 dev/i2o/iopsp.c xs->error = XS_SELTIMEOUT;
xs 438 dev/i2o/iopsp.c scsi_done(xs);
xs 442 dev/i2o/iopsp.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_scsi_cmd: run_xfer\n"));
xs 445 dev/i2o/iopsp.c if ((xs->flags & XS_RESET) != 0) {
xs 452 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 454 dev/i2o/iopsp.c xs->error = XS_NOERROR;
xs 456 dev/i2o/iopsp.c scsi_done(xs);
xs 461 dev/i2o/iopsp.c if (xs->cmdlen > sizeof(mf->cdb))
xs 466 dev/i2o/iopsp.c IM_NOSTATUS | ((xs->flags & SCSI_POLL) != 0 ? IM_POLL : 0));
xs 467 dev/i2o/iopsp.c im->im_dvcontext = xs;
xs 474 dev/i2o/iopsp.c mf->flags = xs->cmdlen | I2O_SCB_FLAG_ENABLE_DISCONNECT |
xs 476 dev/i2o/iopsp.c mf->datalen = xs->datalen;
xs 477 dev/i2o/iopsp.c memcpy(mf->cdb, xs->cmd, xs->cmdlen);
xs 480 dev/i2o/iopsp.c switch (xs->xs_tag_type) {
xs 495 dev/i2o/iopsp.c if (xs->datalen != 0) {
xs 496 dev/i2o/iopsp.c error = iop_msg_map_bio(iop, im, mb, xs->data,
xs 497 dev/i2o/iopsp.c xs->datalen, (xs->flags & SCSI_DATA_OUT) == 0);
xs 499 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 501 dev/i2o/iopsp.c scsi_done(xs);
xs 504 dev/i2o/iopsp.c if ((xs->flags & SCSI_DATA_IN) == 0)
xs 514 dev/i2o/iopsp.c if (iop_msg_post(iop, im, mb, xs->timeout)) {
xs 518 dev/i2o/iopsp.c if (xs->datalen != 0)
xs 521 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 522 dev/i2o/iopsp.c scsi_done(xs);
xs 526 dev/i2o/iopsp.c return (xs->flags & SCSI_POLL? COMPLETE : SUCCESSFULLY_QUEUED);
xs 565 dev/i2o/iopsp.c struct scsi_xfer *xs;
xs 572 dev/i2o/iopsp.c xs = (struct scsi_xfer *)im->im_dvcontext;
xs 576 dev/i2o/iopsp.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_intr\n"));
xs 579 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 580 dev/i2o/iopsp.c xs->resid = xs->datalen;
xs 587 dev/i2o/iopsp.c xs->error = XS_BUSY;
xs 590 dev/i2o/iopsp.c xs->error = XS_SELTIMEOUT;
xs 596 dev/i2o/iopsp.c xs->error = XS_TIMEOUT;
xs 599 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 607 dev/i2o/iopsp.c xs->error = XS_SENSE;
xs 609 dev/i2o/iopsp.c if (sl > sizeof(xs->sense))
xs 610 dev/i2o/iopsp.c sl = sizeof(xs->sense);
xs 611 dev/i2o/iopsp.c bcopy(rb->sense, &xs->sense, sl);
xs 615 dev/i2o/iopsp.c xs->error = XS_BUSY;
xs 618 dev/i2o/iopsp.c xs->error = XS_DRIVER_STUFFUP;
xs 622 dev/i2o/iopsp.c xs->error = XS_NOERROR;
xs 624 dev/i2o/iopsp.c xs->resid = xs->datalen - letoh32(rb->datalen);
xs 625 dev/i2o/iopsp.c xs->status = rb->scsistatus;
xs 629 dev/i2o/iopsp.c if (xs->datalen != 0)
xs 636 dev/i2o/iopsp.c scsi_done(xs);
xs 977 dev/ic/aac.c struct scsi_xfer *xs;
xs 985 dev/ic/aac.c xs = cm->cm_private;
xs 1000 dev/ic/aac.c switch(xs->cmd->opcode) {
xs 1011 dev/ic/aac.c xs->cmd->opcode);
xs 1021 dev/ic/aac.c br->ContainerId = xs->sc_link->target;
xs 1031 dev/ic/aac.c bw->ContainerId = xs->sc_link->target;
xs 1045 dev/ic/aac.c br->ContainerId = xs->sc_link->target;
xs 1057 dev/ic/aac.c bw->ContainerId = xs->sc_link->target;
xs 1085 dev/ic/aac.c struct scsi_xfer *xs = (struct scsi_xfer *)cm->cm_private;
xs 1093 dev/ic/aac.c if (xs->flags & SCSI_DATA_IN) {
xs 1104 dev/ic/aac.c xs->error = status == ST_OK? XS_NOERROR : XS_DRIVER_STUFFUP;
xs 1105 dev/ic/aac.c xs->resid = 0;
xs 1106 dev/ic/aac.c xs->flags |= ITSDONE;
xs 1107 dev/ic/aac.c scsi_done(xs);
xs 2093 dev/ic/aac.c struct scsi_xfer *xs = cm->cm_private;
xs 2095 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2096 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2097 dev/ic/aac.c scsi_done(xs);
xs 2395 dev/ic/aac.c aac_copy_internal_data(struct scsi_xfer *xs, u_int8_t *data, size_t size)
xs 2397 dev/ic/aac.c struct aac_softc *sc = xs->sc_link->adapter_softc;
xs 2403 dev/ic/aac.c if (!xs->datalen)
xs 2407 dev/ic/aac.c copy_cnt = MIN(size, xs->datalen);
xs 2408 dev/ic/aac.c bcopy(data, xs->data, copy_cnt);
xs 2414 dev/ic/aac.c aac_internal_cache_cmd(struct scsi_xfer *xs)
xs 2416 dev/ic/aac.c struct scsi_link *link = xs->sc_link;
xs 2426 dev/ic/aac.c switch (xs->cmd->opcode) {
xs 2432 dev/ic/aac.c AAC_DPRINTF(AAC_D_CMD, ("opc %#x tgt %d ", xs->cmd->opcode,
xs 2444 dev/ic/aac.c aac_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
xs 2461 dev/ic/aac.c aac_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
xs 2469 dev/ic/aac.c aac_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
xs 2475 dev/ic/aac.c xs->cmd->opcode);
xs 2476 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2480 dev/ic/aac.c xs->error = XS_NOERROR;
xs 2511 dev/ic/aac.c aac_raw_scsi_cmd(struct scsi_xfer *xs)
xs 2514 dev/ic/aac.c struct aac_softc *sc = xs->sc_link->adapter_softc;
xs 2520 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2525 dev/ic/aac.c aac_scsi_cmd(struct scsi_xfer *xs)
xs 2527 dev/ic/aac.c struct scsi_link *link = xs->sc_link;
xs 2537 dev/ic/aac.c xs->error = XS_NOERROR;
xs 2545 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2546 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2547 dev/ic/aac.c scsi_done(xs);
xs 2554 dev/ic/aac.c xs->error = XS_NOERROR;
xs 2556 dev/ic/aac.c link = xs->sc_link;
xs 2559 dev/ic/aac.c switch (xs->cmd->opcode) {
xs 2568 dev/ic/aac.c aac_internal_cache_cmd(xs);
xs 2569 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2570 dev/ic/aac.c scsi_done(xs);
xs 2576 dev/ic/aac.c xs->error = XS_NOERROR;
xs 2577 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2578 dev/ic/aac.c scsi_done(xs);
xs 2584 dev/ic/aac.c xs->error = XS_NOERROR;
xs 2585 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2586 dev/ic/aac.c scsi_done(xs);
xs 2590 dev/ic/aac.c AAC_DPRINTF(AAC_D_CMD, ("unknown opc %#x ", xs->cmd->opcode));
xs 2592 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2593 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2594 dev/ic/aac.c scsi_done(xs);
xs 2601 dev/ic/aac.c AAC_DPRINTF(AAC_D_CMD, ("rw opc %#x ", xs->cmd->opcode));
xs 2604 dev/ic/aac.c if (xs->cmdlen == 6) {
xs 2605 dev/ic/aac.c rw = (struct scsi_rw *)xs->cmd;
xs 2610 dev/ic/aac.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 2616 dev/ic/aac.c xs->cmd->opcode, blockno, blockcnt));
xs 2629 dev/ic/aac.c xs->error = XS_DRIVER_STUFFUP;
xs 2630 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2631 dev/ic/aac.c scsi_done(xs);
xs 2647 dev/ic/aac.c cm->cm_data = (void *)xs->data;
xs 2648 dev/ic/aac.c cm->cm_datalen = xs->datalen;
xs 2650 dev/ic/aac.c cm->cm_private = xs;
xs 2661 dev/ic/aac.c if (xs->flags & SCSI_POLL) {
xs 2662 dev/ic/aac.c if (!aac_wait_command(cm, xs->timeout))
xs 2669 dev/ic/aac.c xs->flags |= ITSDONE;
xs 2670 dev/ic/aac.c scsi_done(xs);
xs 2678 dev/ic/aac.c if (xs->flags & SCSI_POLL)
xs 137 dev/ic/adv.c adv_enqueue(sc, xs, infront)
xs 139 dev/ic/adv.c struct scsi_xfer *xs;
xs 145 dev/ic/adv.c sc->sc_queuelast = xs;
xs 146 dev/ic/adv.c LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
xs 149 dev/ic/adv.c LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
xs 150 dev/ic/adv.c sc->sc_queuelast = xs;
xs 161 dev/ic/adv.c struct scsi_xfer *xs;
xs 163 dev/ic/adv.c xs = LIST_FIRST(&sc->sc_queue);
xs 164 dev/ic/adv.c LIST_REMOVE(xs, free_list);
xs 169 dev/ic/adv.c return (xs);
xs 357 dev/ic/adv.c timeout_set(&ccb->xs->stimeout, adv_timeout, ccb);
xs 369 dev/ic/adv.c struct scsi_xfer *xs;
xs 373 dev/ic/adv.c xs = ccb->xs;
xs 375 dev/ic/adv.c timeout_del(&xs->stimeout);
xs 379 dev/ic/adv.c timeout_set(&xs->stimeout, adv_watchdog, ccb);
xs 380 dev/ic/adv.c timeout_add(&xs->stimeout,
xs 386 dev/ic/adv.c if ((ccb->xs->flags & SCSI_POLL) == 0) {
xs 387 dev/ic/adv.c timeout_set(&xs->stimeout, adv_timeout, ccb);
xs 388 dev/ic/adv.c timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
xs 641 dev/ic/adv.c adv_scsi_cmd(xs)
xs 642 dev/ic/adv.c struct scsi_xfer *xs;
xs 644 dev/ic/adv.c struct scsi_link *sc_link = xs->sc_link;
xs 658 dev/ic/adv.c if (xs == LIST_FIRST(&sc->sc_queue)) {
xs 659 dev/ic/adv.c xs = adv_dequeue(sc);
xs 664 dev/ic/adv.c dontqueue = xs->flags & SCSI_POLL;
xs 681 dev/ic/adv.c adv_enqueue(sc, xs, 0);
xs 682 dev/ic/adv.c xs = adv_dequeue(sc);
xs 694 dev/ic/adv.c flags = xs->flags;
xs 707 dev/ic/adv.c adv_enqueue(sc, xs, fromqueue);
xs 713 dev/ic/adv.c ccb->xs = xs;
xs 714 dev/ic/adv.c ccb->timeout = xs->timeout;
xs 723 dev/ic/adv.c ccb->scsiq.cdbptr = &xs->cmd->opcode;
xs 724 dev/ic/adv.c ccb->scsiq.q2.cdb_len = xs->cmdlen;
xs 749 dev/ic/adv.c if (xs->datalen) {
xs 756 dev/ic/adv.c ccb->dmamap_xfer, (struct uio *) xs->data,
xs 762 dev/ic/adv.c ccb->dmamap_xfer, xs->data, xs->datalen, NULL,
xs 777 dev/ic/adv.c xs->error = XS_DRIVER_STUFFUP;
xs 815 dev/ic/adv.c sc_link->scsipi_scsi.lun, xs->cmd->opcode,
xs 831 dev/ic/adv.c if (adv_poll(sc, xs, ccb->timeout)) {
xs 833 dev/ic/adv.c if (adv_poll(sc, xs, ccb->timeout))
xs 845 dev/ic/adv.c struct scsi_xfer *xs;
xs 870 dev/ic/adv.c if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
xs 871 dev/ic/adv.c (void) adv_scsi_cmd(xs);
xs 881 dev/ic/adv.c adv_poll(sc, xs, count)
xs 883 dev/ic/adv.c struct scsi_xfer *xs;
xs 890 dev/ic/adv.c if (xs->flags & ITSDONE)
xs 904 dev/ic/adv.c struct scsi_xfer *xs = ccb->xs;
xs 905 dev/ic/adv.c struct scsi_link *sc_link = xs->sc_link;
xs 930 dev/ic/adv.c ccb->xs->error = XS_TIMEOUT;
xs 945 dev/ic/adv.c struct scsi_xfer *xs = ccb->xs;
xs 946 dev/ic/adv.c struct scsi_link *sc_link = xs->sc_link;
xs 976 dev/ic/adv.c struct scsi_xfer *xs = ccb->xs;
xs 983 dev/ic/adv.c xs->sc_link->scsipi_scsi.target,
xs 984 dev/ic/adv.c xs->sc_link->scsipi_scsi.lun, xs->cmd->opcode);
xs 986 dev/ic/adv.c timeout_del(&xs->stimeout);
xs 992 dev/ic/adv.c if (xs->datalen) {
xs 995 dev/ic/adv.c ((xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 1014 dev/ic/adv.c xs->error = XS_NOERROR;
xs 1015 dev/ic/adv.c xs->resid = 0;
xs 1020 dev/ic/adv.c xs->error = XS_DRIVER_STUFFUP;
xs 1028 dev/ic/adv.c if ((xs->cmd->opcode == SCSICMD_Inquiry) &&
xs 1029 dev/ic/adv.c (xs->sc_link->lun == 0) &&
xs 1030 dev/ic/adv.c (xs->datalen - qdonep->remain_bytes) >= 8) {
xs 1032 dev/ic/adv.c xs->sc_link->target & 0x7,
xs 1033 dev/ic/adv.c (ASC_SCSI_INQUIRY *) xs->data);
xs 1042 dev/ic/adv.c s2 = &xs->sense;
xs 1044 dev/ic/adv.c xs->error = XS_SENSE;
xs 1046 dev/ic/adv.c xs->error = XS_DRIVER_STUFFUP;
xs 1052 dev/ic/adv.c xs->error = XS_DRIVER_STUFFUP;
xs 1059 dev/ic/adv.c xs->error = XS_DRIVER_STUFFUP;
xs 1065 dev/ic/adv.c xs->flags |= ITSDONE;
xs 1066 dev/ic/adv.c scsi_done(xs);
xs 57 dev/ic/adv.h struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 124 dev/ic/adw.c adw_enqueue(sc, xs, infront)
xs 126 dev/ic/adw.c struct scsi_xfer *xs;
xs 132 dev/ic/adw.c sc->sc_queuelast = xs;
xs 133 dev/ic/adw.c LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
xs 136 dev/ic/adw.c LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
xs 137 dev/ic/adw.c sc->sc_queuelast = xs;
xs 148 dev/ic/adw.c struct scsi_xfer *xs;
xs 150 dev/ic/adw.c xs = LIST_FIRST(&sc->sc_queue);
xs 151 dev/ic/adw.c LIST_REMOVE(xs, free_list);
xs 156 dev/ic/adw.c return (xs);
xs 463 dev/ic/adw.c timeout_set(&ccb->xs->stimeout, adw_timeout, ccb);
xs 464 dev/ic/adw.c if ((ccb->xs->flags & SCSI_POLL) == 0)
xs 465 dev/ic/adw.c timeout_add(&ccb->xs->stimeout, (ccb->timeout * hz) / 1000);
xs 655 dev/ic/adw.c adw_scsi_cmd(xs)
xs 656 dev/ic/adw.c struct scsi_xfer *xs;
xs 658 dev/ic/adw.c struct scsi_link *sc_link = xs->sc_link;
xs 670 dev/ic/adw.c if (xs == LIST_FIRST(&sc->sc_queue)) {
xs 671 dev/ic/adw.c if(sc->sc_freeze_dev[xs->sc_link->target]) {
xs 675 dev/ic/adw.c xs = adw_dequeue(sc);
xs 679 dev/ic/adw.c if(sc->sc_freeze_dev[xs->sc_link->target]) {
xs 685 dev/ic/adw.c dontqueue = xs->flags & SCSI_POLL;
xs 702 dev/ic/adw.c adw_enqueue(sc, xs, 0);
xs 703 dev/ic/adw.c xs = adw_dequeue(sc);
xs 715 dev/ic/adw.c flags = xs->flags;
xs 730 dev/ic/adw.c adw_enqueue(sc, xs, fromqueue);
xs 736 dev/ic/adw.c ccb->xs = xs;
xs 737 dev/ic/adw.c ccb->timeout = xs->timeout;
xs 739 dev/ic/adw.c if (adw_build_req(xs, ccb, flags)) {
xs 750 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 757 dev/ic/adw.c if ((xs->flags & SCSI_POLL) == 0)
xs 763 dev/ic/adw.c if (adw_poll(sc, xs, ccb->timeout)) {
xs 765 dev/ic/adw.c if (adw_poll(sc, xs, ccb->timeout))
xs 777 dev/ic/adw.c adw_build_req(xs, ccb, flags)
xs 778 dev/ic/adw.c struct scsi_xfer *xs;
xs 782 dev/ic/adw.c struct scsi_link *sc_link = xs->sc_link;
xs 806 dev/ic/adw.c bcopy(xs->cmd, &scsiqp->cdb, ((scsiqp->cdb_len = xs->cmdlen) <= 12)?
xs 807 dev/ic/adw.c xs->cmdlen : 12 );
xs 808 dev/ic/adw.c if(xs->cmdlen > 12)
xs 809 dev/ic/adw.c bcopy(&(xs->cmd[12]), &scsiqp->cdb16, xs->cmdlen - 12);
xs 822 dev/ic/adw.c if (xs->datalen) {
xs 827 dev/ic/adw.c if (xs->flags & SCSI_DATA_UIO) {
xs 829 dev/ic/adw.c ccb->dmamap_xfer, (struct uio *) xs->data,
xs 836 dev/ic/adw.c ccb->dmamap_xfer, xs->data, xs->datalen, NULL,
xs 852 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 858 dev/ic/adw.c (xs->flags & SCSI_DATA_IN) ?
xs 864 dev/ic/adw.c scsiqp->data_cnt = xs->datalen;
xs 865 dev/ic/adw.c scsiqp->vdata_addr = xs->data;
xs 941 dev/ic/adw.c struct scsi_xfer *xs;
xs 953 dev/ic/adw.c if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
xs 954 dev/ic/adw.c (void) adw_scsi_cmd(xs);
xs 967 dev/ic/adw.c adw_poll(sc, xs, count)
xs 969 dev/ic/adw.c struct scsi_xfer *xs;
xs 976 dev/ic/adw.c if (xs->flags & ITSDONE) {
xs 977 dev/ic/adw.c if ((xs->cmd->opcode == INQUIRY)
xs 978 dev/ic/adw.c && (xs->sc_link->lun == 0)
xs 979 dev/ic/adw.c && (xs->error == XS_NOERROR))
xs 980 dev/ic/adw.c adw_print_info(sc, xs->sc_link->target);
xs 995 dev/ic/adw.c struct scsi_xfer *xs = ccb->xs;
xs 996 dev/ic/adw.c struct scsi_link *sc_link = xs->sc_link;
xs 1012 dev/ic/adw.c timeout_del(&xs->stimeout);
xs 1024 dev/ic/adw.c xs->error = XS_TIMEOUT;
xs 1048 dev/ic/adw.c timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
xs 1056 dev/ic/adw.c xs->error = XS_TIMEOUT;
xs 1080 dev/ic/adw.c timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
xs 1098 dev/ic/adw.c timeout_del(&ccb->xs->stimeout);
xs 1184 dev/ic/adw.c struct scsi_xfer *xs;
xs 1199 dev/ic/adw.c xs = ccb->xs;
xs 1200 dev/ic/adw.c timeout_del(&xs->stimeout);
xs 1207 dev/ic/adw.c if (xs->datalen) {
xs 1210 dev/ic/adw.c ((xs->flags & SCSI_DATA_IN) ?
xs 1222 dev/ic/adw.c xs->status = scsiq->scsi_status;
xs 1227 dev/ic/adw.c xs->resid = scsiq->data_cnt;
xs 1228 dev/ic/adw.c xs->error = XS_NOERROR;
xs 1253 dev/ic/adw.c s2 = &xs->sense;
xs 1255 dev/ic/adw.c xs->error = XS_SENSE;
xs 1262 dev/ic/adw.c xs->error = XS_BUSY;
xs 1269 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 1275 dev/ic/adw.c xs->error = XS_SELTIMEOUT;
xs 1296 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 1319 dev/ic/adw.c xs->error = XS_RESET;
xs 1336 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 1351 dev/ic/adw.c xs->error = XS_DRIVER_STUFFUP;
xs 1357 dev/ic/adw.c xs->flags |= ITSDONE;
xs 1358 dev/ic/adw.c scsi_done(xs);
xs 78 dev/ic/adw.h struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 406 dev/ic/aic6360.c acb->xs->error = XS_DRIVER_STUFFUP;
xs 407 dev/ic/aic6360.c timeout_del(&acb->xs->stimeout);
xs 411 dev/ic/aic6360.c acb->xs->error = XS_DRIVER_STUFFUP;
xs 412 dev/ic/aic6360.c timeout_del(&acb->xs->stimeout);
xs 508 dev/ic/aic6360.c aic_scsi_cmd(struct scsi_xfer *xs)
xs 510 dev/ic/aic6360.c struct scsi_link *sc_link = xs->sc_link;
xs 516 dev/ic/aic6360.c AIC_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
xs 519 dev/ic/aic6360.c flags = xs->flags;
xs 525 dev/ic/aic6360.c acb->xs = xs;
xs 526 dev/ic/aic6360.c acb->timeout = xs->timeout;
xs 527 dev/ic/aic6360.c timeout_set(&xs->stimeout, aic_timeout, acb);
xs 529 dev/ic/aic6360.c if (xs->flags & SCSI_RESET) {
xs 534 dev/ic/aic6360.c bcopy(xs->cmd, &acb->scsi_cmd, xs->cmdlen);
xs 535 dev/ic/aic6360.c acb->scsi_cmd_length = xs->cmdlen;
xs 536 dev/ic/aic6360.c acb->data_addr = xs->data;
xs 537 dev/ic/aic6360.c acb->data_length = xs->datalen;
xs 553 dev/ic/aic6360.c if (aic_poll(sc, xs, acb->timeout)) {
xs 555 dev/ic/aic6360.c if (aic_poll(sc, xs, acb->timeout))
xs 580 dev/ic/aic6360.c aic_poll(struct aic_softc *sc, struct scsi_xfer *xs, int count)
xs 593 dev/ic/aic6360.c if ((xs->flags & ITSDONE) != 0)
xs 643 dev/ic/aic6360.c struct scsi_link *sc_link = acb->xs->sc_link;
xs 690 dev/ic/aic6360.c sc_link = acb->xs->sc_link;
xs 754 dev/ic/aic6360.c sc_link = acb->xs->sc_link;
xs 777 dev/ic/aic6360.c struct scsi_xfer *xs = acb->xs;
xs 778 dev/ic/aic6360.c struct scsi_link *sc_link = xs->sc_link;
xs 789 dev/ic/aic6360.c acb->data_addr = (char *)&xs->sense;
xs 811 dev/ic/aic6360.c struct scsi_xfer *xs = acb->xs;
xs 812 dev/ic/aic6360.c struct scsi_link *sc_link = xs->sc_link;
xs 825 dev/ic/aic6360.c if (xs->error == XS_NOERROR) {
xs 827 dev/ic/aic6360.c xs->error = XS_DRIVER_STUFFUP;
xs 829 dev/ic/aic6360.c xs->error = XS_SENSE;
xs 832 dev/ic/aic6360.c xs->resid = acb->data_length;
xs 833 dev/ic/aic6360.c xs->status = acb->target_stat;
xs 837 dev/ic/aic6360.c xs->resid = acb->data_length;
xs 841 dev/ic/aic6360.c xs->flags |= ITSDONE;
xs 845 dev/ic/aic6360.c if (xs->resid != 0)
xs 846 dev/ic/aic6360.c printf("resid=%lu ", (u_long)xs->resid);
xs 847 dev/ic/aic6360.c if (xs->error == XS_SENSE)
xs 848 dev/ic/aic6360.c printf("sense=0x%02x\n", xs->sense.error_code);
xs 850 dev/ic/aic6360.c printf("error=%d\n", xs->error);
xs 866 dev/ic/aic6360.c aic_free_acb(sc, acb, xs->flags);
xs 868 dev/ic/aic6360.c scsi_done(xs);
xs 997 dev/ic/aic6360.c ti = &sc->sc_tinfo[acb->xs->sc_link->target];
xs 1002 dev/ic/aic6360.c sc_link = acb->xs->sc_link;
xs 1008 dev/ic/aic6360.c acb->xs->resid = acb->data_length = sc->sc_dleft;
xs 1083 dev/ic/aic6360.c sc_print_addr(acb->xs->sc_link);
xs 1104 dev/ic/aic6360.c sc_print_addr(acb->xs->sc_link);
xs 1234 dev/ic/aic6360.c MSG_IDENTIFY(sc->sc_nexus->xs->sc_link->lun, 1);
xs 1241 dev/ic/aic6360.c ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target];
xs 1254 dev/ic/aic6360.c ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target];
xs 1735 dev/ic/aic6360.c sc_link = acb->xs->sc_link;
xs 1764 dev/ic/aic6360.c if ((acb->xs->flags & SCSI_POLL) == 0)
xs 1765 dev/ic/aic6360.c timeout_add(&acb->xs->stimeout,
xs 1787 dev/ic/aic6360.c acb->xs->error = XS_SELTIMEOUT;
xs 1841 dev/ic/aic6360.c sc_link = acb->xs->sc_link;
xs 1877 dev/ic/aic6360.c acb->xs->error = XS_DRIVER_STUFFUP;
xs 1983 dev/ic/aic6360.c timeout_del(&acb->xs->stimeout);
xs 2024 dev/ic/aic6360.c struct scsi_xfer *xs = acb->xs;
xs 2025 dev/ic/aic6360.c struct scsi_link *sc_link = xs->sc_link;
xs 2041 dev/ic/aic6360.c acb->xs->error = XS_TIMEOUT;
xs 2058 dev/ic/aic6360.c struct scsi_link *sc_link = acb->xs->sc_link;
xs 2062 dev/ic/aic6360.c if ((acb->xs->flags & SCSI_RESET) == 0) {
xs 2077 dev/ic/aic6360.c printf("acb@%p xs=%p flags=%x", acb, acb->xs, acb->flags);
xs 89 dev/ic/aic6360var.h struct scsi_xfer *xs; /* SCSI xfer ctrl block from above */
xs 9172 dev/ic/aic79xx.c if (list_scb->xs)
xs 9173 dev/ic/aic79xx.c timeout_del(&list_scb->xs->stimeout);
xs 655 dev/ic/aic79xx.h struct scsi_xfer *xs;
xs 175 dev/ic/aic79xx_openbsd.c struct scsi_xfer *xs = scb->xs;
xs 182 dev/ic/aic79xx_openbsd.c timeout_del(&xs->stimeout);
xs 184 dev/ic/aic79xx_openbsd.c if (xs->datalen) {
xs 187 dev/ic/aic79xx_openbsd.c if ((xs->flags & SCSI_DATA_IN) != 0)
xs 197 dev/ic/aic79xx_openbsd.c switch (xs->error) {
xs 201 dev/ic/aic79xx_openbsd.c switch (xs->status) {
xs 209 dev/ic/aic79xx_openbsd.c xs->error = XS_TIMEOUT;
xs 210 dev/ic/aic79xx_openbsd.c xs->retries++;
xs 213 dev/ic/aic79xx_openbsd.c xs->error = XS_BUSY;
xs 219 dev/ic/aic79xx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 221 dev/ic/aic79xx_openbsd.c xs->error = XS_NOERROR;
xs 224 dev/ic/aic79xx_openbsd.c xs->error = XS_NOERROR;
xs 229 dev/ic/aic79xx_openbsd.c xs->error = XS_BUSY;
xs 232 dev/ic/aic79xx_openbsd.c xs->error = XS_TIMEOUT;
xs 236 dev/ic/aic79xx_openbsd.c xs->error = XS_RESET;
xs 239 dev/ic/aic79xx_openbsd.c xs->error = XS_TIMEOUT;
xs 240 dev/ic/aic79xx_openbsd.c xs->retries++;
xs 243 dev/ic/aic79xx_openbsd.c xs->error = XS_SELTIMEOUT;
xs 246 dev/ic/aic79xx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 250 dev/ic/aic79xx_openbsd.c if (xs->error != XS_NOERROR) {
xs 263 dev/ic/aic79xx_openbsd.c memset(&xs->sense, 0, sizeof(struct scsi_sense_data));
xs 264 dev/ic/aic79xx_openbsd.c memcpy(&xs->sense, ahd_get_sense_buf(ahd, scb),
xs 266 dev/ic/aic79xx_openbsd.c xs->error = XS_SENSE;
xs 273 dev/ic/aic79xx_openbsd.c memset(&xs->sense, 0, sizeof(xs->sense));
xs 274 dev/ic/aic79xx_openbsd.c memcpy(&xs->sense, SIU_SENSE_DATA(siu),
xs 275 dev/ic/aic79xx_openbsd.c ulmin(len, sizeof(xs->sense)));
xs 276 dev/ic/aic79xx_openbsd.c xs->error = XS_SENSE;
xs 283 dev/ic/aic79xx_openbsd.c xs->flags |= ITSDONE;
xs 284 dev/ic/aic79xx_openbsd.c scsi_done(xs);
xs 304 dev/ic/aic79xx_openbsd.c ahd_action(struct scsi_xfer *xs)
xs 318 dev/ic/aic79xx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("ahd_action\n"));
xs 319 dev/ic/aic79xx_openbsd.c ahd = (struct ahd_softc *)xs->sc_link->adapter_softc;
xs 322 dev/ic/aic79xx_openbsd.c dontqueue = xs->flags & SCSI_POLL;
xs 324 dev/ic/aic79xx_openbsd.c target_id = xs->sc_link->target;
xs 325 dev/ic/aic79xx_openbsd.c our_id = SCSI_SCSI_ID(ahd, xs->sc_link);
xs 328 dev/ic/aic79xx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 329 dev/ic/aic79xx_openbsd.c xs->flags |= ITSDONE;
xs 330 dev/ic/aic79xx_openbsd.c scsi_done(xs);
xs 340 dev/ic/aic79xx_openbsd.c quirks = xs->sc_link->quirks;
xs 346 dev/ic/aic79xx_openbsd.c col_idx = AHD_BUILD_COL_IDX(target_id, xs->sc_link->lun);
xs 357 dev/ic/aic79xx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("start scb(%p)\n", scb));
xs 359 dev/ic/aic79xx_openbsd.c scb->xs = xs;
xs 360 dev/ic/aic79xx_openbsd.c timeout_set(&xs->stimeout, ahd_timeout, scb);
xs 366 dev/ic/aic79xx_openbsd.c hscb->scsiid = BUILD_SCSIID(ahd, xs->sc_link, target_id, our_id);
xs 367 dev/ic/aic79xx_openbsd.c hscb->lun = xs->sc_link->lun;
xs 368 dev/ic/aic79xx_openbsd.c if (xs->xs_control & XS_CTL_RESET) {
xs 376 dev/ic/aic79xx_openbsd.c return (ahd_setup_data(ahd, xs, scb));
xs 384 dev/ic/aic79xx_openbsd.c struct scsi_xfer *xs;
xs 392 dev/ic/aic79xx_openbsd.c xs = scb->xs;
xs 393 dev/ic/aic79xx_openbsd.c xs->error = CAM_REQ_INPROG;
xs 394 dev/ic/aic79xx_openbsd.c xs->status = 0;
xs 395 dev/ic/aic79xx_openbsd.c ahd = (struct ahd_softc *)xs->sc_link->adapter_softc;
xs 413 dev/ic/aic79xx_openbsd.c if ((xs->flags & SCSI_DATA_IN) != 0)
xs 429 dev/ic/aic79xx_openbsd.c if (xs->flags & ITSDONE) {
xs 466 dev/ic/aic79xx_openbsd.c if (!(xs->flags & SCSI_POLL))
xs 467 dev/ic/aic79xx_openbsd.c timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
xs 482 dev/ic/aic79xx_openbsd.c if (!(xs->flags & SCSI_POLL)) {
xs 483 dev/ic/aic79xx_openbsd.c int target = xs->sc_link->target;
xs 505 dev/ic/aic79xx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("cmd_poll\n"));
xs 508 dev/ic/aic79xx_openbsd.c if (ahd_poll(ahd, xs->timeout)) {
xs 509 dev/ic/aic79xx_openbsd.c if (!(xs->flags & SCSI_SILENT))
xs 514 dev/ic/aic79xx_openbsd.c } while (!(xs->flags & ITSDONE));
xs 539 dev/ic/aic79xx_openbsd.c ahd_setup_data(struct ahd_softc *ahd, struct scsi_xfer *xs,
xs 546 dev/ic/aic79xx_openbsd.c xs->resid = xs->status = 0;
xs 547 dev/ic/aic79xx_openbsd.c xs->error = CAM_REQ_INPROG;
xs 549 dev/ic/aic79xx_openbsd.c hscb->cdb_len = xs->cmdlen;
xs 554 dev/ic/aic79xx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 555 dev/ic/aic79xx_openbsd.c xs->flags |= ITSDONE;
xs 556 dev/ic/aic79xx_openbsd.c scsi_done(xs);
xs 560 dev/ic/aic79xx_openbsd.c memcpy(hscb->shared_data.idata.cdb, xs->cmd, hscb->cdb_len);
xs 563 dev/ic/aic79xx_openbsd.c if (xs->datalen) {
xs 567 dev/ic/aic79xx_openbsd.c scb->dmamap, xs->data,
xs 568 dev/ic/aic79xx_openbsd.c xs->datalen, NULL,
xs 569 dev/ic/aic79xx_openbsd.c ((xs->flags & SCSI_NOSLEEP) ?
xs 572 dev/ic/aic79xx_openbsd.c ((xs->flags & XS_CTL_DATA_IN) ?
xs 664 dev/ic/aic79xx_openbsd.c target_id = scb->xs->sc_link->target;
xs 665 dev/ic/aic79xx_openbsd.c our_id = SCSI_SCSI_ID(ahd, scb->xs->sc_link);
xs 669 dev/ic/aic79xx_openbsd.c quirks = scb->xs->sc_link->quirks;
xs 748 dev/ic/aic79xx_openbsd.c if (!(scb->xs->xs_control & XS_CTL_POLL))
xs 749 dev/ic/aic79xx_openbsd.c callout_reset(&scb->xs->xs_callout, ticks, ahd_timeout, scb);
xs 772 dev/ic/aic79xx_openbsd.c timeout_del(&scb->xs->stimeout);
xs 781 dev/ic/aic79xx_openbsd.c sc_print_addr(scb->xs->sc_link);
xs 165 dev/ic/aic79xx_openbsd.h #define aic_get_timeout(scb) ((scb)->xs->timeout)
xs 216 dev/ic/aic79xx_openbsd.h #define aic_set_transaction_status(scb, status) (scb)->xs->error = (status)
xs 217 dev/ic/aic79xx_openbsd.h #define aic_set_scsi_status(scb, status) (scb)->xs->xs_status = (status)
xs 219 dev/ic/aic79xx_openbsd.h #define aic_set_residual(scb, residual) (scb)->xs->resid = (residual)
xs 220 dev/ic/aic79xx_openbsd.h #define aic_set_sense_residual(scb, residual) (scb)->xs->resid = (residual)
xs 223 dev/ic/aic79xx_openbsd.h (((scb)->xs->flags & ITSDONE) ? CAM_REQ_CMP : (scb)->xs->error)
xs 224 dev/ic/aic79xx_openbsd.h #define aic_get_scsi_status(scb) ((scb)->xs->status)
xs 225 dev/ic/aic79xx_openbsd.h #define aic_get_transfer_length(scb) ((scb)->xs->datalen)
xs 227 dev/ic/aic79xx_openbsd.h ((scb)->xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT))
xs 228 dev/ic/aic79xx_openbsd.h #define aic_get_residual(scb) ((scb)->xs->resid)
xs 5391 dev/ic/aic7xxx.c ahc_search_untagged_queues(struct ahc_softc *ahc, struct scsi_xfer *xs,
xs 5449 dev/ic/aic7xxx.c || (xs != NULL && xs != scb->xs))
xs 175 dev/ic/aic7xxx_openbsd.c struct scsi_xfer *xs = scb->xs;
xs 194 dev/ic/aic7xxx_openbsd.c timeout_del(&xs->stimeout);
xs 196 dev/ic/aic7xxx_openbsd.c if (xs->datalen) {
xs 199 dev/ic/aic7xxx_openbsd.c if ((xs->flags & SCSI_DATA_IN) != 0)
xs 209 dev/ic/aic7xxx_openbsd.c switch (xs->error) {
xs 213 dev/ic/aic7xxx_openbsd.c switch (xs->status) {
xs 221 dev/ic/aic7xxx_openbsd.c xs->error = XS_TIMEOUT;
xs 222 dev/ic/aic7xxx_openbsd.c xs->retries++;
xs 225 dev/ic/aic7xxx_openbsd.c xs->error = XS_BUSY;
xs 231 dev/ic/aic7xxx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 233 dev/ic/aic7xxx_openbsd.c xs->error = XS_NOERROR;
xs 236 dev/ic/aic7xxx_openbsd.c xs->error = XS_NOERROR;
xs 241 dev/ic/aic7xxx_openbsd.c xs->error = XS_BUSY;
xs 244 dev/ic/aic7xxx_openbsd.c xs->error = XS_TIMEOUT;
xs 248 dev/ic/aic7xxx_openbsd.c xs->error = XS_RESET;
xs 251 dev/ic/aic7xxx_openbsd.c xs->error = XS_TIMEOUT;
xs 252 dev/ic/aic7xxx_openbsd.c xs->retries++;
xs 255 dev/ic/aic7xxx_openbsd.c xs->error = XS_SELTIMEOUT;
xs 258 dev/ic/aic7xxx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 263 dev/ic/aic7xxx_openbsd.c if (xs->error != XS_NOERROR) {
xs 276 dev/ic/aic7xxx_openbsd.c memset(&xs->sense, 0, sizeof(struct scsi_sense_data));
xs 277 dev/ic/aic7xxx_openbsd.c memcpy(&xs->sense, ahc_get_sense_buf(ahc, scb),
xs 279 dev/ic/aic7xxx_openbsd.c xs->error = XS_SENSE;
xs 286 dev/ic/aic7xxx_openbsd.c xs->flags |= ITSDONE;
xs 287 dev/ic/aic7xxx_openbsd.c scsi_done(xs);
xs 308 dev/ic/aic7xxx_openbsd.c ahc_action(struct scsi_xfer *xs)
xs 318 dev/ic/aic7xxx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("ahc_action\n"));
xs 319 dev/ic/aic7xxx_openbsd.c ahc = (struct ahc_softc *)xs->sc_link->adapter_softc;
xs 322 dev/ic/aic7xxx_openbsd.c dontqueue = xs->flags & SCSI_POLL;
xs 324 dev/ic/aic7xxx_openbsd.c target_id = xs->sc_link->target;
xs 325 dev/ic/aic7xxx_openbsd.c our_id = SCSI_SCSI_ID(ahc, xs->sc_link);
xs 339 dev/ic/aic7xxx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("start scb(%p)\n", scb));
xs 340 dev/ic/aic7xxx_openbsd.c scb->xs = xs;
xs 341 dev/ic/aic7xxx_openbsd.c timeout_set(&xs->stimeout, ahc_timeout, scb);
xs 347 dev/ic/aic7xxx_openbsd.c hscb->scsiid = BUILD_SCSIID(ahc, xs->sc_link, target_id, our_id);
xs 348 dev/ic/aic7xxx_openbsd.c hscb->lun = xs->sc_link->lun;
xs 349 dev/ic/aic7xxx_openbsd.c if (xs->xs_control & XS_CTL_RESET) {
xs 356 dev/ic/aic7xxx_openbsd.c return (ahc_setup_data(ahc, xs, scb));
xs 363 dev/ic/aic7xxx_openbsd.c struct scsi_xfer *xs;
xs 372 dev/ic/aic7xxx_openbsd.c xs = scb->xs;
xs 373 dev/ic/aic7xxx_openbsd.c xs->error = CAM_REQ_INPROG;
xs 374 dev/ic/aic7xxx_openbsd.c xs->status = 0;
xs 375 dev/ic/aic7xxx_openbsd.c ahc = (struct ahc_softc *)xs->sc_link->adapter_softc;
xs 405 dev/ic/aic7xxx_openbsd.c if ((xs->flags & SCSI_DATA_IN) != 0)
xs 437 dev/ic/aic7xxx_openbsd.c if (xs->flags & ITSDONE) {
xs 475 dev/ic/aic7xxx_openbsd.c if (!(xs->flags & SCSI_POLL))
xs 476 dev/ic/aic7xxx_openbsd.c timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
xs 498 dev/ic/aic7xxx_openbsd.c if (xs->flags & SCSI_POLL)
xs 520 dev/ic/aic7xxx_openbsd.c if (!(xs->flags & SCSI_POLL)) {
xs 521 dev/ic/aic7xxx_openbsd.c if (ahc->inited_target[xs->sc_link->target] == 0) {
xs 529 dev/ic/aic7xxx_openbsd.c ahc->inited_target[xs->sc_link->target] = 1;
xs 539 dev/ic/aic7xxx_openbsd.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("cmd_poll\n"));
xs 542 dev/ic/aic7xxx_openbsd.c if (ahc_poll(ahc, xs->timeout)) {
xs 543 dev/ic/aic7xxx_openbsd.c if (!(xs->flags & SCSI_SILENT))
xs 548 dev/ic/aic7xxx_openbsd.c } while (!(xs->flags & ITSDONE));
xs 573 dev/ic/aic7xxx_openbsd.c ahc_setup_data(struct ahc_softc *ahc, struct scsi_xfer *xs,
xs 580 dev/ic/aic7xxx_openbsd.c xs->resid = xs->status = 0;
xs 581 dev/ic/aic7xxx_openbsd.c xs->error = CAM_REQ_INPROG;
xs 583 dev/ic/aic7xxx_openbsd.c hscb->cdb_len = xs->cmdlen;
xs 588 dev/ic/aic7xxx_openbsd.c xs->error = XS_DRIVER_STUFFUP;
xs 589 dev/ic/aic7xxx_openbsd.c xs->flags |= ITSDONE;
xs 590 dev/ic/aic7xxx_openbsd.c scsi_done(xs);
xs 595 dev/ic/aic7xxx_openbsd.c memcpy(hscb->cdb32, xs->cmd, hscb->cdb_len);
xs 598 dev/ic/aic7xxx_openbsd.c memcpy(hscb->shared_data.cdb, xs->cmd, hscb->cdb_len);
xs 602 dev/ic/aic7xxx_openbsd.c if (xs->datalen) {
xs 606 dev/ic/aic7xxx_openbsd.c scb->dmamap, xs->data,
xs 607 dev/ic/aic7xxx_openbsd.c xs->datalen, NULL,
xs 608 dev/ic/aic7xxx_openbsd.c (xs->flags & SCSI_NOSLEEP) ?
xs 640 dev/ic/aic7xxx_openbsd.c ahc = (struct ahc_softc *)scb->xs->sc_link->adapter_softc;
xs 660 dev/ic/aic7xxx_openbsd.c if (list_scb->xs)
xs 661 dev/ic/aic7xxx_openbsd.c timeout_del(&list_scb->xs->stimeout);
xs 745 dev/ic/aic7xxx_openbsd.c quirks = scb->xs->sc_link->quirks;
xs 172 dev/ic/aic7xxx_openbsd.h if (!(scb->xs->xs_control & XS_CTL_POLL)) {
xs 173 dev/ic/aic7xxx_openbsd.h callout_reset(&scb->xs->xs_callout,
xs 226 dev/ic/aic7xxx_openbsd.h scb->xs->error = status;
xs 232 dev/ic/aic7xxx_openbsd.h scb->xs->status = status;
xs 238 dev/ic/aic7xxx_openbsd.h if (scb->xs->flags & ITSDONE)
xs 241 dev/ic/aic7xxx_openbsd.h return scb->xs->error;
xs 247 dev/ic/aic7xxx_openbsd.h return (scb->xs->status);
xs 258 dev/ic/aic7xxx_openbsd.h return (scb->xs->datalen);
xs 264 dev/ic/aic7xxx_openbsd.h return (scb->xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT));
xs 270 dev/ic/aic7xxx_openbsd.h scb->xs->resid = resid;
xs 276 dev/ic/aic7xxx_openbsd.h scb->xs->resid = resid;
xs 282 dev/ic/aic7xxx_openbsd.h return (scb->xs->resid);
xs 327 dev/ic/aic7xxx_openbsd.h timeout_del(&scb->xs->stimeout);
xs 395 dev/ic/aic7xxx_openbsd.h sc_print_addr(scb->xs->sc_link);
xs 597 dev/ic/aic7xxxvar.h struct scsipi_xfer *xs;
xs 936 dev/ic/ami.c ami_start_xs(struct ami_softc *sc, struct ami_ccb *ccb, struct scsi_xfer *xs)
xs 938 dev/ic/ami.c timeout_set(&xs->stimeout, ami_stimeout, ccb);
xs 940 dev/ic/ami.c if (xs->flags & SCSI_POLL) {
xs 941 dev/ic/ami.c ami_complete(sc, ccb, xs->timeout);
xs 945 dev/ic/ami.c timeout_add(&xs->stimeout, 61 * hz);
xs 1135 dev/ic/ami.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1136 dev/ic/ami.c struct scsi_link *link = xs->sc_link;
xs 1144 dev/ic/ami.c if (xs->data != NULL) {
xs 1147 dev/ic/ami.c (xs->flags & SCSI_DATA_IN) ?
xs 1153 dev/ic/ami.c timeout_del(&xs->stimeout);
xs 1154 dev/ic/ami.c xs->resid = 0;
xs 1155 dev/ic/ami.c xs->flags |= ITSDONE;
xs 1158 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1159 dev/ic/ami.c else if (xs->flags & SCSI_POLL && xs->cmd->opcode == INQUIRY) {
xs 1160 dev/ic/ami.c type = ((struct scsi_inquiry_data *)xs->data)->device &
xs 1163 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1169 dev/ic/ami.c scsi_done(xs);
xs 1175 dev/ic/ami.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1177 dev/ic/ami.c if (xs->data != NULL) {
xs 1180 dev/ic/ami.c (xs->flags & SCSI_DATA_IN) ?
xs 1190 dev/ic/ami.c timeout_del(&xs->stimeout);
xs 1191 dev/ic/ami.c xs->resid = 0;
xs 1192 dev/ic/ami.c xs->flags |= ITSDONE;
xs 1195 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1198 dev/ic/ami.c scsi_done(xs);
xs 1204 dev/ic/ami.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1207 dev/ic/ami.c timeout_del(&xs->stimeout);
xs 1209 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1210 dev/ic/ami.c xs->resid = 0;
xs 1211 dev/ic/ami.c xs->flags |= ITSDONE;
xs 1214 dev/ic/ami.c scsi_done(xs);
xs 1222 dev/ic/ami.c ami_start_xs(sc, ccb, xs);
xs 1228 dev/ic/ami.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1230 dev/ic/ami.c timeout_del(&xs->stimeout);
xs 1231 dev/ic/ami.c xs->resid = 0;
xs 1232 dev/ic/ami.c xs->flags |= ITSDONE;
xs 1234 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1237 dev/ic/ami.c scsi_done(xs);
xs 1261 dev/ic/ami.c ami_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size)
xs 1267 dev/ic/ami.c if (!xs->datalen)
xs 1270 dev/ic/ami.c copy_cnt = MIN(size, xs->datalen);
xs 1271 dev/ic/ami.c bcopy(v, xs->data, copy_cnt);
xs 1276 dev/ic/ami.c ami_scsi_raw_cmd(struct scsi_xfer *xs)
xs 1278 dev/ic/ami.c struct scsi_link *link = xs->sc_link;
xs 1292 dev/ic/ami.c if (xs->cmdlen > AMI_MAX_CDB) {
xs 1293 dev/ic/ami.c AMI_DPRINTF(AMI_D_CMD, ("CDB too big %p ", xs));
xs 1294 dev/ic/ami.c bzero(&xs->sense, sizeof(xs->sense));
xs 1295 dev/ic/ami.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 1296 dev/ic/ami.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 1297 dev/ic/ami.c xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
xs 1298 dev/ic/ami.c xs->error = XS_SENSE;
xs 1300 dev/ic/ami.c scsi_done(xs);
xs 1305 dev/ic/ami.c xs->error = XS_NOERROR;
xs 1311 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1313 dev/ic/ami.c scsi_done(xs);
xs 1320 dev/ic/ami.c ccb->ccb_xs = xs;
xs 1329 dev/ic/ami.c bcopy(xs->cmd, ccb->ccb_pt->apt_cdb, AMI_MAX_CDB);
xs 1330 dev/ic/ami.c ccb->ccb_pt->apt_ncdb = xs->cmdlen;
xs 1332 dev/ic/ami.c ccb->ccb_pt->apt_datalen = xs->datalen;
xs 1335 dev/ic/ami.c if (ami_load_ptmem(sc, ccb, xs->data, xs->datalen,
xs 1336 dev/ic/ami.c xs->flags & SCSI_DATA_IN, xs->flags & SCSI_NOSLEEP) != 0) {
xs 1337 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1340 dev/ic/ami.c scsi_done(xs);
xs 1345 dev/ic/ami.c return (ami_start_xs(sc, ccb, xs));
xs 1397 dev/ic/ami.c ami_scsi_cmd(struct scsi_xfer *xs)
xs 1399 dev/ic/ami.c struct scsi_link *link = xs->sc_link;
xs 1422 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1423 dev/ic/ami.c xs->flags |= ITSDONE;
xs 1425 dev/ic/ami.c scsi_done(xs);
xs 1431 dev/ic/ami.c xs->error = XS_NOERROR;
xs 1433 dev/ic/ami.c switch (xs->cmd->opcode) {
xs 1446 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1448 dev/ic/ami.c scsi_done(xs);
xs 1453 dev/ic/ami.c ccb->ccb_xs = xs;
xs 1455 dev/ic/ami.c if (xs->timeout < 30000)
xs 1456 dev/ic/ami.c xs->timeout = 30000; /* at least 30sec */
xs 1461 dev/ic/ami.c return (ami_start_xs(sc, ccb, xs));
xs 1473 dev/ic/ami.c AMI_DPRINTF(AMI_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
xs 1485 dev/ic/ami.c ami_copy_internal_data(xs, &sd, sizeof(sd));
xs 1487 dev/ic/ami.c scsi_done(xs);
xs 1503 dev/ic/ami.c ami_copy_internal_data(xs, &inq, sizeof(inq));
xs 1505 dev/ic/ami.c scsi_done(xs);
xs 1514 dev/ic/ami.c ami_copy_internal_data(xs, &rcd, sizeof(rcd));
xs 1516 dev/ic/ami.c scsi_done(xs);
xs 1522 dev/ic/ami.c xs->cmd->opcode, target));
xs 1523 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1525 dev/ic/ami.c scsi_done(xs);
xs 1531 dev/ic/ami.c if (xs->cmdlen == 6) {
xs 1532 dev/ic/ami.c rw = (struct scsi_rw *)xs->cmd;
xs 1536 dev/ic/ami.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 1545 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1547 dev/ic/ami.c scsi_done(xs);
xs 1556 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1558 dev/ic/ami.c scsi_done(xs);
xs 1563 dev/ic/ami.c ccb->ccb_xs = xs;
xs 1567 dev/ic/ami.c cmd->acc_cmd = (xs->flags & SCSI_DATA_IN) ? AMI_READ : AMI_WRITE;
xs 1573 dev/ic/ami.c xs->data, xs->datalen, NULL,
xs 1574 dev/ic/ami.c (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
xs 1581 dev/ic/ami.c xs->error = XS_DRIVER_STUFFUP;
xs 1584 dev/ic/ami.c scsi_done(xs);
xs 1610 dev/ic/ami.c ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
xs 1613 dev/ic/ami.c return (ami_start_xs(sc, ccb, xs));
xs 135 dev/ic/bha.c bha_enqueue(sc, xs, infront)
xs 137 dev/ic/bha.c struct scsi_xfer *xs;
xs 143 dev/ic/bha.c sc->sc_queuelast = xs;
xs 144 dev/ic/bha.c LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
xs 148 dev/ic/bha.c LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
xs 149 dev/ic/bha.c sc->sc_queuelast = xs;
xs 159 dev/ic/bha.c struct scsi_xfer *xs;
xs 161 dev/ic/bha.c xs = LIST_FIRST(&sc->sc_queue);
xs 162 dev/ic/bha.c LIST_REMOVE(xs, free_list);
xs 167 dev/ic/bha.c return (xs);
xs 448 dev/ic/bha.c timeout_del(&ccb->xs->stimeout);
xs 674 dev/ic/bha.c timeout_set(&ccb->xs->stimeout, bha_timeout, ccb);
xs 723 dev/ic/bha.c struct scsi_xfer *xs;
xs 729 dev/ic/bha.c xs = ccb->xs;
xs 764 dev/ic/bha.c if ((xs->flags & SCSI_POLL) == 0)
xs 765 dev/ic/bha.c timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
xs 786 dev/ic/bha.c struct scsi_xfer *xs = ccb->xs;
xs 788 dev/ic/bha.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("bha_done\n"));
xs 794 dev/ic/bha.c if (xs->datalen) {
xs 797 dev/ic/bha.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 820 dev/ic/bha.c if (xs->error == XS_NOERROR) {
xs 824 dev/ic/bha.c xs->error = XS_SELTIMEOUT;
xs 829 dev/ic/bha.c xs->error = XS_DRIVER_STUFFUP;
xs 836 dev/ic/bha.c s2 = &xs->sense;
xs 838 dev/ic/bha.c xs->error = XS_SENSE;
xs 841 dev/ic/bha.c xs->error = XS_BUSY;
xs 846 dev/ic/bha.c xs->error = XS_DRIVER_STUFFUP;
xs 850 dev/ic/bha.c xs->resid = 0;
xs 853 dev/ic/bha.c xs->flags |= ITSDONE;
xs 854 dev/ic/bha.c scsi_done(xs);
xs 864 dev/ic/bha.c if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
xs 865 dev/ic/bha.c (void) bha_scsi_cmd(xs);
xs 1344 dev/ic/bha.c bha_scsi_cmd(xs)
xs 1345 dev/ic/bha.c struct scsi_xfer *xs;
xs 1347 dev/ic/bha.c struct scsi_link *sc_link = xs->sc_link;
xs 1362 dev/ic/bha.c if (xs == LIST_FIRST(&sc->sc_queue)) {
xs 1363 dev/ic/bha.c xs = bha_dequeue(sc);
xs 1369 dev/ic/bha.c dontqueue = xs->flags & SCSI_POLL;
xs 1387 dev/ic/bha.c bha_enqueue(sc, xs, 0);
xs 1388 dev/ic/bha.c xs = bha_dequeue(sc);
xs 1398 dev/ic/bha.c flags = xs->flags;
xs 1412 dev/ic/bha.c bha_enqueue(sc, xs, fromqueue);
xs 1419 dev/ic/bha.c ccb->xs = xs;
xs 1420 dev/ic/bha.c ccb->timeout = xs->timeout;
xs 1430 dev/ic/bha.c ccb->opcode = (xs->datalen ? BHA_INIT_SCAT_GATH_CCB
xs 1432 dev/ic/bha.c bcopy(xs->cmd, &ccb->scsi_cmd,
xs 1433 dev/ic/bha.c ccb->scsi_cmd_length = xs->cmdlen);
xs 1436 dev/ic/bha.c if (xs->datalen) {
xs 1443 dev/ic/bha.c ccb->dmamap_xfer, (struct uio *)xs->data,
xs 1450 dev/ic/bha.c ccb->dmamap_xfer, xs->data, xs->datalen, NULL,
xs 1528 dev/ic/bha.c if (bha_poll(sc, xs, ccb->timeout)) {
xs 1530 dev/ic/bha.c if (bha_poll(sc, xs, ccb->timeout))
xs 1536 dev/ic/bha.c xs->error = XS_DRIVER_STUFFUP;
xs 1545 dev/ic/bha.c bha_poll(sc, xs, count)
xs 1547 dev/ic/bha.c struct scsi_xfer *xs;
xs 1562 dev/ic/bha.c if (xs->flags & ITSDONE)
xs 1575 dev/ic/bha.c struct scsi_xfer *xs = ccb->xs;
xs 1576 dev/ic/bha.c struct scsi_link *sc_link = xs->sc_link;
xs 1608 dev/ic/bha.c ccb->xs->error = XS_TIMEOUT;
xs 248 dev/ic/bhareg.h struct scsi_xfer *xs; /* the scsipi_xfer for this cmd */
xs 115 dev/ic/cac.c int drive, int blkno, int flags, struct scsi_xfer *xs);
xs 119 dev/ic/cac.c void cac_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size);
xs 318 dev/ic/cac.c int drive, int blkno, int flags, struct scsi_xfer *xs)
xs 326 dev/ic/cac.c command, drive, blkno, data, datasize, flags, xs);
xs 376 dev/ic/cac.c ccb->ccb_xs = xs;
xs 378 dev/ic/cac.c if (!xs || xs->flags & SCSI_POLL) {
xs 444 dev/ic/cac.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 448 dev/ic/cac.c printf("%s: CCB not active, xs=%p\n", sc->sc_dv.dv_xname, xs);
xs 449 dev/ic/cac.c if (xs) {
xs 450 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 451 dev/ic/cac.c scsi_done(xs);
xs 476 dev/ic/cac.c if (xs) {
xs 478 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 480 dev/ic/cac.c xs->resid = 0;
xs 482 dev/ic/cac.c xs->flags |= ITSDONE;
xs 483 dev/ic/cac.c scsi_done(xs);
xs 541 dev/ic/cac.c cac_copy_internal_data(xs, v, size)
xs 542 dev/ic/cac.c struct scsi_xfer *xs;
xs 548 dev/ic/cac.c if (!xs->datalen)
xs 551 dev/ic/cac.c copy_cnt = MIN(size, xs->datalen);
xs 552 dev/ic/cac.c bcopy(v, xs->data, copy_cnt);
xs 557 dev/ic/cac.c cac_scsi_cmd(xs)
xs 558 dev/ic/cac.c struct scsi_xfer *xs;
xs 560 dev/ic/cac.c struct scsi_link *link = xs->sc_link;
xs 574 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 579 dev/ic/cac.c xs->error = XS_NOERROR;
xs 580 dev/ic/cac.c xs->free_list.le_next = NULL;
xs 583 dev/ic/cac.c switch (xs->cmd->opcode) {
xs 598 dev/ic/cac.c cac_copy_internal_data(xs, &sd, sizeof sd);
xs 603 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 623 dev/ic/cac.c cac_copy_internal_data(xs, &inq, sizeof inq);
xs 628 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 635 dev/ic/cac.c cac_copy_internal_data(xs, &rcd, sizeof rcd);
xs 643 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 653 dev/ic/cac.c if (xs->cmdlen == 6) {
xs 654 dev/ic/cac.c rw = (struct scsi_rw *)xs->cmd;
xs 659 dev/ic/cac.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 668 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 669 dev/ic/cac.c scsi_done(xs);
xs 673 dev/ic/cac.c switch (xs->cmd->opcode) {
xs 686 dev/ic/cac.c poll = xs->flags & SCSI_POLL;
xs 687 dev/ic/cac.c if ((error = cac_cmd(sc, op, xs->data, blockcnt * DEV_BSIZE,
xs 688 dev/ic/cac.c target, blockno, flags, xs))) {
xs 697 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 698 dev/ic/cac.c scsi_done(xs);
xs 712 dev/ic/cac.c "tgt %d ", xs->cmd->opcode, target));
xs 713 dev/ic/cac.c xs->error = XS_DRIVER_STUFFUP;
xs 72 dev/ic/ciss.c int ciss_scsi_cmd(struct scsi_xfer *xs);
xs 85 dev/ic/ciss.c int ciss_scsi_raw_cmd(struct scsi_xfer *xs);
xs 618 dev/ic/ciss.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 639 dev/ic/ciss.c ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
xs 648 dev/ic/ciss.c if (xs) {
xs 649 dev/ic/ciss.c xs->resid = 0;
xs 650 dev/ic/ciss.c xs->flags |= ITSDONE;
xs 651 dev/ic/ciss.c CISS_DPRINTF(CISS_D_CMD, ("scsi_done(%p) ", xs));
xs 652 dev/ic/ciss.c scsi_done(xs);
xs 664 dev/ic/ciss.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 676 dev/ic/ciss.c if (xs) {
xs 677 dev/ic/ciss.c bzero(&xs->sense, sizeof(xs->sense));
xs 678 dev/ic/ciss.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 679 dev/ic/ciss.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 680 dev/ic/ciss.c xs->sense.add_sense_code = 0x24; /* ill field */
xs 681 dev/ic/ciss.c xs->error = XS_SENSE;
xs 687 dev/ic/ciss.c xs->error = XS_TIMEOUT;
xs 692 dev/ic/ciss.c if (xs) {
xs 695 dev/ic/ciss.c xs->error = XS_SENSE;
xs 696 dev/ic/ciss.c bcopy(&err->sense[0], &xs->sense,
xs 697 dev/ic/ciss.c sizeof(xs->sense));
xs 702 dev/ic/ciss.c xs->error = XS_BUSY;
xs 710 dev/ic/ciss.c xs->error = XS_DRIVER_STUFFUP;
xs 714 dev/ic/ciss.c xs->resid = letoh32(err->resid);
xs 823 dev/ic/ciss.c ciss_scsi_raw_cmd(struct scsi_xfer *xs) /* TODO */
xs 825 dev/ic/ciss.c struct scsi_link *link = xs->sc_link;
xs 835 dev/ic/ciss.c if (xs->cmdlen > CISS_MAX_CDB) {
xs 836 dev/ic/ciss.c CISS_DPRINTF(CISS_D_CMD, ("CDB too big %p ", xs));
xs 837 dev/ic/ciss.c bzero(&xs->sense, sizeof(xs->sense));
xs 838 dev/ic/ciss.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 839 dev/ic/ciss.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 840 dev/ic/ciss.c xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
xs 841 dev/ic/ciss.c xs->error = XS_SENSE;
xs 842 dev/ic/ciss.c scsi_done(xs);
xs 848 dev/ic/ciss.c xs->error = XS_NOERROR;
xs 854 dev/ic/ciss.c ccb->ccb_len = xs->datalen;
xs 855 dev/ic/ciss.c ccb->ccb_data = xs->data;
xs 856 dev/ic/ciss.c ccb->ccb_xs = xs;
xs 860 dev/ic/ciss.c cmd->cdblen = xs->cmdlen;
xs 862 dev/ic/ciss.c if (xs->flags & SCSI_DATA_IN)
xs 864 dev/ic/ciss.c else if (xs->flags & SCSI_DATA_OUT)
xs 866 dev/ic/ciss.c cmd->tmo = htole16(xs->timeout < 1000? 1 : xs->timeout / 1000);
xs 868 dev/ic/ciss.c bcopy(xs->cmd, &cmd->cdb[0], CISS_MAX_CDB);
xs 871 dev/ic/ciss.c xs->flags & (SCSI_POLL|SCSI_NOSLEEP))) {
xs 872 dev/ic/ciss.c xs->error = XS_DRIVER_STUFFUP;
xs 873 dev/ic/ciss.c scsi_done(xs);
xs 879 dev/ic/ciss.c return xs->flags & SCSI_POLL? COMPLETE : SUCCESSFULLY_QUEUED;
xs 883 dev/ic/ciss.c ciss_scsi_cmd(struct scsi_xfer *xs)
xs 885 dev/ic/ciss.c struct scsi_link *link = xs->sc_link;
xs 895 dev/ic/ciss.c if (xs->cmdlen > CISS_MAX_CDB) {
xs 896 dev/ic/ciss.c CISS_DPRINTF(CISS_D_CMD, ("CDB too big %p ", xs));
xs 897 dev/ic/ciss.c bzero(&xs->sense, sizeof(xs->sense));
xs 898 dev/ic/ciss.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 899 dev/ic/ciss.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 900 dev/ic/ciss.c xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
xs 901 dev/ic/ciss.c xs->error = XS_SENSE;
xs 902 dev/ic/ciss.c scsi_done(xs);
xs 908 dev/ic/ciss.c xs->error = XS_NOERROR;
xs 914 dev/ic/ciss.c ccb->ccb_len = xs->datalen;
xs 915 dev/ic/ciss.c ccb->ccb_data = xs->data;
xs 916 dev/ic/ciss.c ccb->ccb_xs = xs;
xs 919 dev/ic/ciss.c cmd->cdblen = xs->cmdlen;
xs 921 dev/ic/ciss.c if (xs->flags & SCSI_DATA_IN)
xs 923 dev/ic/ciss.c else if (xs->flags & SCSI_DATA_OUT)
xs 925 dev/ic/ciss.c cmd->tmo = htole16(xs->timeout < 1000? 1 : xs->timeout / 1000);
xs 927 dev/ic/ciss.c bcopy(xs->cmd, &cmd->cdb[0], CISS_MAX_CDB);
xs 930 dev/ic/ciss.c xs->flags & (SCSI_POLL|SCSI_NOSLEEP))) {
xs 931 dev/ic/ciss.c xs->error = XS_DRIVER_STUFFUP;
xs 932 dev/ic/ciss.c scsi_done(xs);
xs 938 dev/ic/ciss.c return xs->flags & SCSI_POLL? COMPLETE : SUCCESSFULLY_QUEUED;
xs 791 dev/ic/dpt.c struct scsipi_xfer *xs;
xs 795 dev/ic/dpt.c struct scsi_xfer *xs;
xs 800 dev/ic/dpt.c xs = ccb->ccb_xs;
xs 802 dev/ic/dpt.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("dpt_done_ccb\n"));
xs 808 dev/ic/dpt.c if (xs->datalen) {
xs 811 dev/ic/dpt.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 827 dev/ic/dpt.c if (xs->error == XS_NOERROR) {
xs 831 dev/ic/dpt.c xs->error = XS_SELTIMEOUT;
xs 834 dev/ic/dpt.c xs->error = XS_RESET;
xs 839 dev/ic/dpt.c xs->error = XS_DRIVER_STUFFUP;
xs 846 dev/ic/dpt.c s2 = &xs->sense.scsi_sense;
xs 849 dev/ic/dpt.c s2 = &xs->sense;
xs 852 dev/ic/dpt.c xs->error = XS_SENSE;
xs 855 dev/ic/dpt.c xs->error = XS_BUSY;
xs 860 dev/ic/dpt.c xs->error = XS_DRIVER_STUFFUP;
xs 863 dev/ic/dpt.c xs->resid = 0;
xs 865 dev/ic/dpt.c xs->status = ccb->ccb_scsi_status;
xs 871 dev/ic/dpt.c xs->xs_status |= XS_STS_DONE;
xs 872 dev/ic/dpt.c scsipi_done(xs);
xs 875 dev/ic/dpt.c xs->flags |= ITSDONE;
xs 876 dev/ic/dpt.c scsi_done(xs);
xs 886 dev/ic/dpt.c if ((xs = TAILQ_FIRST(&sc->sc_queue)) != NULL)
xs 889 dev/ic/dpt.c if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
xs 891 dev/ic/dpt.c dpt_scsi_cmd(xs);
xs 901 dev/ic/dpt.c dpt_enqueue(sc, xs, infront)
xs 903 dev/ic/dpt.c struct scsi_xfer *xs;
xs 909 dev/ic/dpt.c sc->sc_queuelast = xs;
xs 910 dev/ic/dpt.c LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
xs 913 dev/ic/dpt.c LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
xs 914 dev/ic/dpt.c sc->sc_queuelast = xs;
xs 924 dev/ic/dpt.c struct scsi_xfer *xs;
xs 926 dev/ic/dpt.c xs = LIST_FIRST(&sc->sc_queue);
xs 927 dev/ic/dpt.c LIST_REMOVE(xs, free_list);
xs 932 dev/ic/dpt.c return (xs);
xs 940 dev/ic/dpt.c dpt_scsi_cmd(xs)
xs 942 dev/ic/dpt.c struct scsipi_xfer *xs;
xs 945 dev/ic/dpt.c struct scsi_xfer *xs;
xs 962 dev/ic/dpt.c sc_link = xs->sc_link;
xs 964 dev/ic/dpt.c flags = xs->xs_control;
xs 967 dev/ic/dpt.c flags = xs->flags;
xs 984 dev/ic/dpt.c if (xs == TAILQ_FIRST(&sc->sc_queue)) {
xs 985 dev/ic/dpt.c TAILQ_REMOVE(&sc->sc_queue, xs, adapter_q);
xs 988 dev/ic/dpt.c if (xs == LIST_FIRST(&sc->sc_queue)) {
xs 989 dev/ic/dpt.c xs = dpt_dequeue(sc);
xs 994 dev/ic/dpt.c if (xs->cmdlen > 12) {
xs 996 dev/ic/dpt.c xs->error = XS_DRIVER_STUFFUP;
xs 1005 dev/ic/dpt.c if ((xs->flags & SCSI_RESET) != 0) {
xs 1008 dev/ic/dpt.c xs->error = XS_DRIVER_STUFFUP;
xs 1017 dev/ic/dpt.c dontqueue = xs->flags & SCSI_POLL;
xs 1038 dev/ic/dpt.c TAILQ_INSERT_TAIL(&sc->sc_queue, xs, adapter_q);
xs 1039 dev/ic/dpt.c xs = TAILQ_FIRST(&sc->sc_queue);
xs 1040 dev/ic/dpt.c TAILQ_REMOVE(&sc->sc_queue, xs, adapter_q);
xs 1043 dev/ic/dpt.c dpt_enqueue(sc, xs, 0);
xs 1044 dev/ic/dpt.c xs = dpt_dequeue(sc);
xs 1055 dev/ic/dpt.c if ((ccb = dpt_alloc_ccb(sc, xs->flags)) == NULL) {
xs 1069 dev/ic/dpt.c TAILQ_INSERT_HEAD(&sc->sc_queue, xs, adapter_q);
xs 1071 dev/ic/dpt.c TAILQ_INSERT_TAIL(&sc->sc_queue, xs, adapter_q);
xs 1074 dev/ic/dpt.c dpt_enqueue(sc, xs, fromqueue);
xs 1082 dev/ic/dpt.c ccb->ccb_xs = xs;
xs 1083 dev/ic/dpt.c ccb->ccb_timeout = xs->timeout;
xs 1087 dev/ic/dpt.c memcpy(&cp->cp_scsi_cmd, xs->cmd, xs->cmdlen);
xs 1090 dev/ic/dpt.c bcopy(xs->cmd, &cp->cp_scsi_cmd, xs->cmdlen);
xs 1115 dev/ic/dpt.c cp->cp_datain = ((xs->flags & SCSI_DATA_IN) != 0);
xs 1116 dev/ic/dpt.c cp->cp_dataout = ((xs->flags & SCSI_DATA_OUT) != 0);
xs 1121 dev/ic/dpt.c if (xs->bp != NULL && (xs->bp->b_flags & (B_ASYNC | B_READ)) == 0)
xs 1129 dev/ic/dpt.c if (xs->datalen) {
xs 1135 dev/ic/dpt.c (struct uio *)xs->data, (flags & XS_CTL_NOSLEEP) ?
xs 1139 dev/ic/dpt.c if ((xs->flags & SCSI_DATA_UIO) != 0) {
xs 1141 dev/ic/dpt.c (xs->flags & SCSI_NOSLEEP) ?
xs 1148 dev/ic/dpt.c error = bus_dmamap_load(dmat, xfer, xs->data,
xs 1149 dev/ic/dpt.c xs->datalen, NULL, (flags & XS_CTL_NOSLEEP) ?
xs 1153 dev/ic/dpt.c error = bus_dmamap_load(dmat, xfer, xs->data,
xs 1154 dev/ic/dpt.c xs->datalen, NULL, (xs->flags & SCSI_NOSLEEP) ?
xs 1166 dev/ic/dpt.c xs->error = XS_DRIVER_STUFFUP;
xs 1248 dev/ic/dpt.c struct scsipi_xfer *xs;
xs 1252 dev/ic/dpt.c struct scsi_xfer *xs;
xs 1259 dev/ic/dpt.c xs = ccb->ccb_xs;
xs 1260 dev/ic/dpt.c sc_link = xs->sc_link;
xs 549 dev/ic/gdt_common.c gdt_enqueue(gdt, xs, infront)
xs 551 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 556 dev/ic/gdt_common.c gdt->sc_queuelast = xs;
xs 557 dev/ic/gdt_common.c LIST_INSERT_HEAD(&gdt->sc_queue, xs, free_list);
xs 560 dev/ic/gdt_common.c LIST_INSERT_AFTER(gdt->sc_queuelast, xs, free_list);
xs 561 dev/ic/gdt_common.c gdt->sc_queuelast = xs;
xs 571 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 573 dev/ic/gdt_common.c xs = LIST_FIRST(&gdt->sc_queue);
xs 574 dev/ic/gdt_common.c if (xs == NULL)
xs 576 dev/ic/gdt_common.c LIST_REMOVE(xs, free_list);
xs 581 dev/ic/gdt_common.c return (xs);
xs 589 dev/ic/gdt_common.c gdt_scsi_cmd(xs)
xs 590 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 592 dev/ic/gdt_common.c struct scsi_link *link = xs->sc_link;
xs 608 dev/ic/gdt_common.c xs->error = XS_NOERROR;
xs 616 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 617 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 619 dev/ic/gdt_common.c scsi_done(xs);
xs 627 dev/ic/gdt_common.c if (xs != LIST_FIRST(&gdt->sc_queue))
xs 628 dev/ic/gdt_common.c gdt_enqueue(gdt, xs, 0);
xs 630 dev/ic/gdt_common.c while ((xs = gdt_dequeue(gdt)) != NULL) {
xs 631 dev/ic/gdt_common.c xs->error = XS_NOERROR;
xs 633 dev/ic/gdt_common.c link = xs->sc_link;
xs 636 dev/ic/gdt_common.c if (!gdt_polling && !(xs->flags & SCSI_POLL) &&
xs 642 dev/ic/gdt_common.c gdt_enqueue(gdt, xs, 1);
xs 646 dev/ic/gdt_common.c switch (xs->cmd->opcode) {
xs 656 dev/ic/gdt_common.c gdt_internal_cache_cmd(xs);
xs 657 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 658 dev/ic/gdt_common.c scsi_done(xs);
xs 664 dev/ic/gdt_common.c xs->error = XS_NOERROR;
xs 665 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 666 dev/ic/gdt_common.c scsi_done(xs);
xs 671 dev/ic/gdt_common.c ("unknown opc %d ", xs->cmd->opcode));
xs 673 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 674 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 675 dev/ic/gdt_common.c scsi_done(xs);
xs 688 dev/ic/gdt_common.c if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 690 dev/ic/gdt_common.c if (xs->cmdlen == 6) {
xs 691 dev/ic/gdt_common.c rw = (struct scsi_rw *)xs->cmd;
xs 697 dev/ic/gdt_common.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 714 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 715 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 716 dev/ic/gdt_common.c scsi_done(xs);
xs 721 dev/ic/gdt_common.c ccb = gdt_get_ccb(gdt, xs->flags);
xs 732 dev/ic/gdt_common.c ccb->gc_xs = xs;
xs 733 dev/ic/gdt_common.c ccb->gc_timeout = xs->timeout;
xs 737 dev/ic/gdt_common.c if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 740 dev/ic/gdt_common.c xs->data, xs->datalen, NULL,
xs 741 dev/ic/gdt_common.c (xs->flags & SCSI_NOSLEEP) ?
xs 756 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 757 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 758 dev/ic/gdt_common.c scsi_done(xs);
xs 763 dev/ic/gdt_common.c (xs->flags & SCSI_DATA_IN) ?
xs 770 dev/ic/gdt_common.c if (gdt_polling || (xs->flags & SCSI_POLL)) {
xs 778 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 779 dev/ic/gdt_common.c scsi_done(xs);
xs 787 dev/ic/gdt_common.c if (xs->flags & SCSI_POLL) {
xs 802 dev/ic/gdt_common.c struct scsi_xfer *xs = ccb->gc_xs;
xs 803 dev/ic/gdt_common.c struct scsi_link *link = xs->sc_link;
xs 815 dev/ic/gdt_common.c GDT_DPRINTF(GDT_D_CMD, ("gdt_exec_ccb(%p, %p) ", xs, ccb));
xs 831 dev/ic/gdt_common.c switch (xs->cmd->opcode) {
xs 834 dev/ic/gdt_common.c if (xs->cmd->opcode == PREVENT_ALLOW) {
xs 858 dev/ic/gdt_common.c if (xs->cmd->opcode != PREVENT_ALLOW &&
xs 859 dev/ic/gdt_common.c xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 907 dev/ic/gdt_common.c xs->error = XS_BUSY;
xs 917 dev/ic/gdt_common.c xs->error = XS_NOERROR;
xs 918 dev/ic/gdt_common.c xs->resid = 0;
xs 926 dev/ic/gdt_common.c gdt_copy_internal_data(xs, data, size)
xs 927 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 935 dev/ic/gdt_common.c if (!xs->datalen)
xs 938 dev/ic/gdt_common.c copy_cnt = MIN(size, xs->datalen);
xs 939 dev/ic/gdt_common.c bcopy(data, xs->data, copy_cnt);
xs 945 dev/ic/gdt_common.c gdt_internal_cache_cmd(xs)
xs 946 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 948 dev/ic/gdt_common.c struct scsi_link *link = xs->sc_link;
xs 957 dev/ic/gdt_common.c switch (xs->cmd->opcode) {
xs 963 dev/ic/gdt_common.c GDT_DPRINTF(GDT_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
xs 975 dev/ic/gdt_common.c gdt_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
xs 993 dev/ic/gdt_common.c gdt_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
xs 1001 dev/ic/gdt_common.c gdt_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
xs 1006 dev/ic/gdt_common.c xs->cmd->opcode, target));
xs 1007 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 1011 dev/ic/gdt_common.c xs->error = XS_NOERROR;
xs 1016 dev/ic/gdt_common.c gdt_raw_scsi_cmd(xs)
xs 1017 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 1019 dev/ic/gdt_common.c struct scsi_link *link = xs->sc_link;
xs 1026 dev/ic/gdt_common.c if (xs->cmdlen > 12 /* XXX create #define */) {
xs 1027 dev/ic/gdt_common.c GDT_DPRINTF(GDT_D_CMD, ("CDB too big %p ", xs));
xs 1028 dev/ic/gdt_common.c bzero(&xs->sense, sizeof(xs->sense));
xs 1029 dev/ic/gdt_common.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 1030 dev/ic/gdt_common.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 1031 dev/ic/gdt_common.c xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
xs 1032 dev/ic/gdt_common.c xs->error = XS_SENSE;
xs 1034 dev/ic/gdt_common.c scsi_done(xs);
xs 1039 dev/ic/gdt_common.c if ((ccb = gdt_get_ccb(gdt, xs->flags)) == NULL) {
xs 1040 dev/ic/gdt_common.c GDT_DPRINTF(GDT_D_CMD, ("no ccb available for %p ", xs));
xs 1041 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 1043 dev/ic/gdt_common.c scsi_done(xs);
xs 1048 dev/ic/gdt_common.c xs->error = XS_DRIVER_STUFFUP;
xs 1049 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 1051 dev/ic/gdt_common.c scsi_done(xs);
xs 1085 dev/ic/gdt_common.c gdt_sync_event(gdt, service, index, xs)
xs 1089 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 1092 dev/ic/gdt_common.c ("gdt_sync_event(%p, %d, %d, %p) ", gdt, service, index, xs));
xs 1127 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 1176 dev/ic/gdt_common.c xs = ccb->gc_xs;
xs 1178 dev/ic/gdt_common.c timeout_del(&xs->stimeout);
xs 1181 dev/ic/gdt_common.c if (xs && xs->cmd->opcode != PREVENT_ALLOW &&
xs 1182 dev/ic/gdt_common.c xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 1185 dev/ic/gdt_common.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 1200 dev/ic/gdt_common.c sync_val = gdt_sync_event(gdt, ctx.service, ctx.istatus, xs);
xs 1208 dev/ic/gdt_common.c xs->flags |= ITSDONE;
xs 1209 dev/ic/gdt_common.c scsi_done(xs);
xs 1213 dev/ic/gdt_common.c gdt_enqueue(gdt, xs, 0);
xs 1405 dev/ic/gdt_common.c struct scsi_xfer *xs;
xs 1411 dev/ic/gdt_common.c xs = ccb->gc_xs;
xs 1413 dev/ic/gdt_common.c timeout_del(&xs->stimeout);
xs 1418 dev/ic/gdt_common.c timeout_add(&xs->stimeout,
xs 1424 dev/ic/gdt_common.c if ((xs->flags & SCSI_POLL) == 0) {
xs 1426 dev/ic/gdt_common.c timeout_add(&xs->stimeout,
xs 263 dev/ic/iha.c iha_scsi_cmd(xs)
xs 264 dev/ic/iha.c struct scsi_xfer *xs;
xs 267 dev/ic/iha.c struct scsi_link *sc_link = xs->sc_link;
xs 271 dev/ic/iha.c if ((xs->cmdlen > 12) || (sc_link->target >= IHA_MAX_TARGETS)) {
xs 272 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 286 dev/ic/iha.c pScb->SCB_Flags = xs->flags;
xs 290 dev/ic/iha.c if ((xs->cmd->opcode != REQUEST_SENSE)
xs 294 dev/ic/iha.c pScb->SCB_Xs = xs;
xs 295 dev/ic/iha.c pScb->SCB_CDBLen = xs->cmdlen;
xs 296 dev/ic/iha.c bcopy(xs->cmd, &pScb->SCB_CDB, xs->cmdlen);
xs 298 dev/ic/iha.c pScb->SCB_BufCharsLeft = pScb->SCB_BufChars = xs->datalen;
xs 304 dev/ic/iha.c pScb->SCB_DataDma, (struct uio *)xs->data,
xs 310 dev/ic/iha.c xs->data, pScb->SCB_BufChars, NULL,
xs 315 dev/ic/iha.c sc_print_addr(xs->sc_link);
xs 325 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 336 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 347 dev/ic/iha.c timeout_set(&xs->stimeout, iha_timeout, pScb);
xs 349 dev/ic/iha.c timeout_add(&xs->stimeout, (xs->timeout/1000) * hz);
xs 353 dev/ic/iha.c if ((xs->flags & ITSDONE) == 0)
xs 755 dev/ic/iha.c iha_abort_xs(sc, xs, hastat)
xs 757 dev/ic/iha.c struct scsi_xfer *xs;
xs 769 dev/ic/iha.c if (pScb->SCB_Xs == xs) {
xs 786 dev/ic/iha.c if (pScb->SCB_Xs == xs) {
xs 2484 dev/ic/iha.c struct scsi_xfer *xs = pScb->SCB_Xs;
xs 2486 dev/ic/iha.c if (xs != NULL) {
xs 2487 dev/ic/iha.c timeout_del(&xs->stimeout);
xs 2489 dev/ic/iha.c xs->status = pScb->SCB_TaStat;
xs 2512 dev/ic/iha.c xs->resid = pScb->SCB_BufCharsLeft;
xs 2513 dev/ic/iha.c xs->error = XS_NOERROR;
xs 2519 dev/ic/iha.c xs->error = XS_BUSY;
xs 2526 dev/ic/iha.c s2 = &xs->sense;
xs 2529 dev/ic/iha.c xs->error = XS_SENSE;
xs 2533 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 2539 dev/ic/iha.c xs->error = XS_SELTIMEOUT;
xs 2544 dev/ic/iha.c xs->error = XS_RESET;
xs 2548 dev/ic/iha.c sc_print_addr(xs->sc_link);
xs 2550 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 2554 dev/ic/iha.c xs->error = XS_TIMEOUT;
xs 2560 dev/ic/iha.c xs->error = XS_DRIVER_STUFFUP;
xs 2564 dev/ic/iha.c xs->flags |= ITSDONE;
xs 2565 dev/ic/iha.c scsi_done(xs);
xs 2576 dev/ic/iha.c struct scsi_xfer *xs = pScb->SCB_Xs;
xs 2578 dev/ic/iha.c if (xs != NULL) {
xs 2579 dev/ic/iha.c sc_print_addr(xs->sc_link);
xs 2580 dev/ic/iha.c printf("SCSI OpCode 0x%02x timed out\n", xs->cmd->opcode);
xs 2581 dev/ic/iha.c iha_abort_xs(xs->sc_link->adapter_softc, xs, HOST_TIMED_OUT);
xs 2923 dev/ic/isp.c isp_start(XS_T *xs)
xs 2931 dev/ic/isp.c XS_INITERR(xs);
xs 2932 dev/ic/isp.c isp = XS_ISP(xs);
xs 2938 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 2948 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 2959 dev/ic/isp.c if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
xs 2962 dev/ic/isp.c XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
xs 2963 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 2971 dev/ic/isp.c target = XS_TGT(xs);
xs 2993 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 2998 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3031 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3052 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3057 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3062 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3076 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3137 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3143 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 3150 dev/ic/isp.c xs->sc_link->node_wwn = lp->node_wwn;
xs 3151 dev/ic/isp.c xs->sc_link->port_wwn = lp->port_wwn;
xs 3165 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3195 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3206 dev/ic/isp.c if (XS_CDBLEN(xs) > 12)
xs 3224 dev/ic/isp.c if (XS_TAG_P(xs)) {
xs 3225 dev/ic/isp.c ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
xs 3231 dev/ic/isp.c if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
xs 3238 dev/ic/isp.c sdp += XS_CHANNEL(xs);
xs 3240 dev/ic/isp.c XS_TAG_P(xs)) {
xs 3241 dev/ic/isp.c reqp->req_flags = XS_TAG_TYPE(xs);
xs 3244 dev/ic/isp.c reqp->req_target = target | (XS_CHANNEL(xs) << 7);
xs 3246 dev/ic/isp.c reqp->req_lun_trn = XS_LUN(xs);
xs 3247 dev/ic/isp.c reqp->req_cdblen = XS_CDBLEN(xs);
xs 3250 dev/ic/isp.c ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
xs 3252 dev/ic/isp.c ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
xs 3254 dev/ic/isp.c MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
xs 3256 dev/ic/isp.c reqp->req_time = XS_TIME(xs) / 1000;
xs 3257 dev/ic/isp.c if (reqp->req_time == 0 && XS_TIME(xs)) {
xs 3261 dev/ic/isp.c if (isp_save_xs(isp, xs, &handle)) {
xs 3263 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3272 dev/ic/isp.c i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
xs 3281 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 3284 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
xs 3285 dev/ic/isp.c (long) XS_XFRLEN(xs));
xs 3299 dev/ic/isp.c XS_T *xs;
xs 3352 dev/ic/isp.c xs = (XS_T *) arg;
xs 3353 dev/ic/isp.c tgt = XS_TGT(xs);
xs 3354 dev/ic/isp.c handle = isp_find_handle(isp, xs);
xs 3360 dev/ic/isp.c bus = XS_CHANNEL(xs);
xs 3367 dev/ic/isp.c mbs.param[6] = XS_LUN(xs);
xs 3369 dev/ic/isp.c mbs.param[1] = tgt << 8 | XS_LUN(xs);
xs 3373 dev/ic/isp.c (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
xs 3488 dev/ic/isp.c XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
xs 3743 dev/ic/isp.c xs = isp_find_xs(isp, sp->req_handle);
xs 3744 dev/ic/isp.c if (xs == NULL) {
xs 3766 dev/ic/isp.c XS_SETERR(xs, HBA_BUSRESET);
xs 3767 dev/ic/isp.c isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
xs 3770 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3782 dev/ic/isp.c *XS_STSP(xs) = sp->req_scsi_status & 0xff;
xs 3787 dev/ic/isp.c XS_SET_STATE_STAT(isp, xs, sp);
xs 3788 dev/ic/isp.c isp_parse_status(isp, sp, xs);
xs 3789 dev/ic/isp.c if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
xs 3790 dev/ic/isp.c (*XS_STSP(xs) == SCSI_BUSY)) {
xs 3791 dev/ic/isp.c XS_SETERR(xs, HBA_TGTBSY);
xs 3794 dev/ic/isp.c XS_RESID(xs) = sp->req_resid;
xs 3796 dev/ic/isp.c (*XS_STSP(xs) == SCSI_CHECK) &&
xs 3798 dev/ic/isp.c XS_SAVE_SENSE(xs, sp);
xs 3806 dev/ic/isp.c int t = XS_TGT(xs);
xs 3808 dev/ic/isp.c sdp += XS_CHANNEL(xs);
xs 3811 dev/ic/isp.c (1 << XS_CHANNEL(xs));
xs 3815 dev/ic/isp.c XS_RESID(xs) = 0;
xs 3817 dev/ic/isp.c XS_RESID(xs) = sp->req_resid;
xs 3819 dev/ic/isp.c XS_RESID(xs) = 0;
xs 3822 dev/ic/isp.c (*XS_STSP(xs) == SCSI_CHECK) &&
xs 3824 dev/ic/isp.c XS_SAVE_SENSE(xs, sp);
xs 3830 dev/ic/isp.c "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
xs 3838 dev/ic/isp.c *XS_STSP(xs) = SCSI_QFULL;
xs 3839 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 3840 dev/ic/isp.c } else if (XS_NOERR(xs)) {
xs 3846 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3848 dev/ic/isp.c XS_RESID(xs) = XS_XFRLEN(xs);
xs 3854 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 3855 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 3863 dev/ic/isp.c if (XS_XFRLEN(xs)) {
xs 3864 dev/ic/isp.c ISP_DMAFREE(isp, xs, sp->req_handle);
xs 3868 dev/ic/isp.c ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
xs 3869 dev/ic/isp.c (*XS_STSP(xs) != SCSI_GOOD)))) {
xs 3872 dev/ic/isp.c skey = XS_SNSKEY(xs) & 0xf;
xs 3877 dev/ic/isp.c } else if (*XS_STSP(xs) == SCSI_CHECK) {
xs 3882 dev/ic/isp.c isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
xs 3883 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs),
xs 3884 dev/ic/isp.c (ulong)XS_RESID(xs),
xs 3885 dev/ic/isp.c *XS_STSP(xs), skey, XS_ERR(xs));
xs 3890 dev/ic/isp.c complist[ndone++] = xs; /* defer completion call until later */
xs 3915 dev/ic/isp.c xs = complist[i];
xs 3916 dev/ic/isp.c if (xs) {
xs 3918 dev/ic/isp.c isp_done(xs);
xs 4122 dev/ic/isp.c XS_T *xs;
xs 4123 dev/ic/isp.c xs = isp->isp_xflist[i];
xs 4124 dev/ic/isp.c if (xs != NULL) {
xs 4126 dev/ic/isp.c XS_SETERR(xs, HBA_BUSRESET);
xs 4317 dev/ic/isp.c isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
xs 4321 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4322 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 4330 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4331 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4332 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 4338 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
xs 4344 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4399 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
xs 4405 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4406 dev/ic/isp.c isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
xs 4407 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4408 dev/ic/isp.c XS_SETERR(xs, HBA_BUSRESET);
xs 4414 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4415 dev/ic/isp.c isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
xs 4416 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4417 dev/ic/isp.c XS_SETERR(xs, HBA_ABORTED);
xs 4423 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4429 dev/ic/isp.c FCPARAM(isp)->portdb[XS_TGT(xs)].valid &&
xs 4430 dev/ic/isp.c FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) {
xs 4431 dev/ic/isp.c FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1;
xs 4434 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4435 dev/ic/isp.c XS_SETERR(xs, HBA_CMDTIMEOUT);
xs 4440 dev/ic/isp.c XS_RESID(xs) = sp->req_resid;
xs 4442 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4443 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4444 dev/ic/isp.c XS_SETERR(xs, HBA_DATAOVR);
xs 4451 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4457 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4463 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4469 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4474 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4480 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4485 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4490 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4495 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4501 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4507 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4512 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4517 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4524 dev/ic/isp.c if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
xs 4525 dev/ic/isp.c isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
xs 4526 dev/ic/isp.c XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
xs 4528 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4529 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 4534 dev/ic/isp.c XS_RESID(xs) = sp->req_resid;
xs 4535 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4536 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 4542 dev/ic/isp.c isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
xs 4543 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs));
xs 4548 dev/ic/isp.c XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
xs 4553 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4563 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
xs 4582 dev/ic/isp.c *XS_STSP(xs) = SCSI_QFULL;
xs 4583 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 4587 dev/ic/isp.c isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
xs 4588 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs));
xs 4594 dev/ic/isp.c XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
xs 4595 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4596 dev/ic/isp.c XS_SETERR(xs, HBA_ARQFAIL);
xs 4603 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
xs 4606 dev/ic/isp.c sdp += XS_CHANNEL(xs);
xs 4607 dev/ic/isp.c sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
xs 4608 dev/ic/isp.c sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
xs 4609 dev/ic/isp.c isp->isp_update |= (1 << XS_CHANNEL(xs));
xs 4611 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4612 dev/ic/isp.c XS_SETERR(xs, HBA_NOERROR);
xs 4619 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
xs 4622 dev/ic/isp.c sdp += XS_CHANNEL(xs);
xs 4623 dev/ic/isp.c sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
xs 4624 dev/ic/isp.c sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
xs 4625 dev/ic/isp.c isp->isp_update |= (1 << XS_CHANNEL(xs));
xs 4632 dev/ic/isp.c XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
xs 4645 dev/ic/isp.c "port unavailable for target %d", XS_TGT(xs));
xs 4648 dev/ic/isp.c "port logout for target %d", XS_TGT(xs));
xs 4668 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4669 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 4675 dev/ic/isp.c "port changed for target %d", XS_TGT(xs));
xs 4676 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4677 dev/ic/isp.c XS_SETERR(xs, HBA_SELTIMEOUT);
xs 4683 dev/ic/isp.c "port busy for target %d", XS_TGT(xs));
xs 4684 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4685 dev/ic/isp.c XS_SETERR(xs, HBA_TGTBSY);
xs 4694 dev/ic/isp.c if (XS_NOERR(xs)) {
xs 4695 dev/ic/isp.c XS_SETERR(xs, HBA_BOTCH);
xs 4702 dev/ic/isp.c XS_T *xs;
xs 4707 dev/ic/isp.c xs = isp_find_xs(isp, fph);
xs 4708 dev/ic/isp.c if (xs == NULL) {
xs 4720 dev/ic/isp.c XS_SET_STATE_STAT(isp, xs, NULL);
xs 4721 dev/ic/isp.c XS_RESID(xs) = 0;
xs 4722 dev/ic/isp.c *XS_STSP(xs) = SCSI_GOOD;
xs 4723 dev/ic/isp.c if (XS_XFRLEN(xs)) {
xs 4724 dev/ic/isp.c ISP_DMAFREE(isp, xs, fph);
xs 4729 dev/ic/isp.c isp_done(xs);
xs 5819 dev/ic/isp.c XS_T *xs;
xs 5838 dev/ic/isp.c xs = isp_find_xs(isp, handle);
xs 5839 dev/ic/isp.c if (xs == NULL) {
xs 5843 dev/ic/isp.c if (XS_XFRLEN(xs)) {
xs 5844 dev/ic/isp.c ISP_DMAFREE(isp, xs, handle);
xs 5845 dev/ic/isp.c XS_RESID(xs) = XS_XFRLEN(xs);
xs 5847 dev/ic/isp.c XS_RESID(xs) = 0;
xs 5849 dev/ic/isp.c XS_SETERR(xs, HBA_BUSRESET);
xs 5850 dev/ic/isp.c isp_done(xs);
xs 55 dev/ic/isp_inline.h isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int16_t *handlep)
xs 70 dev/ic/isp_inline.h isp->isp_xflist[j] = xs;
xs 89 dev/ic/isp_inline.h isp_find_handle(struct ispsoftc *isp, XS_T *xs)
xs 92 dev/ic/isp_inline.h if (xs != NULL) {
xs 94 dev/ic/isp_inline.h if (isp->isp_xflist[i] == xs) {
xs 117 dev/ic/isp_inline.h isp_remove_handle(struct ispsoftc *isp, XS_T *xs)
xs 119 dev/ic/isp_inline.h isp_destroy_handle(isp, isp_find_handle(isp, xs));
xs 63 dev/ic/isp_openbsd.c #define _XT(xs) ((((xs)->timeout/1000) * hz) + (3 * hz))
xs 199 dev/ic/isp_openbsd.c ispcmd_slow(XS_T *xs)
xs 204 dev/ic/isp_openbsd.c struct ispsoftc *isp = XS_ISP(xs);
xs 211 dev/ic/isp_openbsd.c return (ispcmd(xs));
xs 218 dev/ic/isp_openbsd.c tgt = XS_TGT(xs);
xs 219 dev/ic/isp_openbsd.c chan = XS_CHANNEL(xs);
xs 221 dev/ic/isp_openbsd.c if ((xs->flags & SCSI_POLL) != 0 ||
xs 223 dev/ic/isp_openbsd.c return (ispcmd(xs));
xs 230 dev/ic/isp_openbsd.c if (xs->sc_link->quirks & SDEV_NOSYNC) {
xs 233 dev/ic/isp_openbsd.c if (xs->sc_link->quirks & SDEV_NOWIDE) {
xs 236 dev/ic/isp_openbsd.c if (xs->sc_link->quirks & SDEV_NOTAGS) {
xs 273 dev/ic/isp_openbsd.c return (ispcmd(xs));
xs 279 dev/ic/isp_openbsd.c isp_add2_blocked_queue(struct ispsoftc *isp, XS_T *xs)
xs 282 dev/ic/isp_openbsd.c isp->isp_osinfo.wqt->free_list.le_next = xs;
xs 284 dev/ic/isp_openbsd.c isp->isp_osinfo.wqf = xs;
xs 286 dev/ic/isp_openbsd.c isp->isp_osinfo.wqt = xs;
xs 287 dev/ic/isp_openbsd.c xs->free_list.le_next = NULL;
xs 291 dev/ic/isp_openbsd.c ispcmd(XS_T *xs)
xs 300 dev/ic/isp_openbsd.c isp = XS_ISP(xs);
xs 302 dev/ic/isp_openbsd.c timeout_set(&xs->stimeout, isp_wdog, isp);
xs 304 dev/ic/isp_openbsd.c if (XS_LUN(xs) >= isp->isp_maxluns) {
xs 305 dev/ic/isp_openbsd.c xs->error = XS_SELTIMEOUT;
xs 316 dev/ic/isp_openbsd.c XS_SETERR(xs, HBA_BOTCH);
xs 327 dev/ic/isp_openbsd.c if (xs->flags & SCSI_POLL) {
xs 335 dev/ic/isp_openbsd.c isp_add2_blocked_queue(isp, xs);
xs 342 dev/ic/isp_openbsd.c if (xs->flags & SCSI_POLL) {
xs 345 dev/ic/isp_openbsd.c result = isp_polled_cmd(isp, xs);
xs 351 dev/ic/isp_openbsd.c result = isp_start(xs);
xs 356 dev/ic/isp_openbsd.c if (xs->timeout) {
xs 357 dev/ic/isp_openbsd.c timeout_add(&xs->stimeout, _XT(xs));
xs 358 dev/ic/isp_openbsd.c XS_CMD_S_TIMER(xs);
xs 369 dev/ic/isp_openbsd.c isp_add2_blocked_queue(isp, xs);
xs 375 dev/ic/isp_openbsd.c XS_TGT(xs), XS_LUN(xs));
xs 376 dev/ic/isp_openbsd.c timeout_set(&xs->stimeout, isp_requeue, xs);
xs 377 dev/ic/isp_openbsd.c timeout_add(&xs->stimeout, hz);
xs 378 dev/ic/isp_openbsd.c XS_CMD_S_TIMER(xs);
xs 389 dev/ic/isp_openbsd.c isp_polled_cmd(struct ispsoftc *isp, XS_T *xs)
xs 394 dev/ic/isp_openbsd.c result = isp_start(xs);
xs 417 dev/ic/isp_openbsd.c if ((mswait = XS_TIME(xs)) == 0)
xs 424 dev/ic/isp_openbsd.c if (XS_CMD_DONE_P(xs)) {
xs 436 dev/ic/isp_openbsd.c if (XS_CMD_DONE_P(xs) == 0) {
xs 437 dev/ic/isp_openbsd.c if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
xs 440 dev/ic/isp_openbsd.c if (XS_NOERR(xs)) {
xs 441 dev/ic/isp_openbsd.c XS_SETERR(xs, HBA_BOTCH);
xs 449 dev/ic/isp_openbsd.c isp_done(XS_T *xs)
xs 451 dev/ic/isp_openbsd.c XS_CMD_S_DONE(xs);
xs 452 dev/ic/isp_openbsd.c if (XS_CMD_WDOG_P(xs) == 0) {
xs 453 dev/ic/isp_openbsd.c struct ispsoftc *isp = XS_ISP(xs);
xs 454 dev/ic/isp_openbsd.c if (XS_CMD_TIMER_P(xs)) {
xs 455 dev/ic/isp_openbsd.c timeout_del(&xs->stimeout);
xs 456 dev/ic/isp_openbsd.c XS_CMD_C_TIMER(xs);
xs 458 dev/ic/isp_openbsd.c if (XS_CMD_GRACE_P(xs)) {
xs 459 dev/ic/isp_openbsd.c struct ispsoftc *isp = XS_ISP(xs);
xs 463 dev/ic/isp_openbsd.c XS_CMD_S_CLEAR(xs);
xs 464 dev/ic/isp_openbsd.c scsi_done(xs);
xs 476 dev/ic/isp_openbsd.c XS_T *xs = arg;
xs 477 dev/ic/isp_openbsd.c struct ispsoftc *isp = XS_ISP(xs);
xs 486 dev/ic/isp_openbsd.c handle = isp_find_handle(isp, xs);
xs 490 dev/ic/isp_openbsd.c if (XS_CMD_DONE_P(xs)) {
xs 498 dev/ic/isp_openbsd.c if (XS_CMD_WDOG_P(xs)) {
xs 506 dev/ic/isp_openbsd.c XS_CMD_S_WDOG(xs);
xs 512 dev/ic/isp_openbsd.c if (XS_CMD_DONE_P(xs)) {
xs 515 dev/ic/isp_openbsd.c XS_CMD_C_WDOG(xs);
xs 516 dev/ic/isp_openbsd.c isp_done(xs);
xs 517 dev/ic/isp_openbsd.c } else if (XS_CMD_GRACE_P(xs)) {
xs 527 dev/ic/isp_openbsd.c if (XS_XFRLEN(xs)) {
xs 528 dev/ic/isp_openbsd.c ISP_DMAFREE(isp, xs, handle);
xs 533 dev/ic/isp_openbsd.c XS_SETERR(xs, XS_TIMEOUT);
xs 534 dev/ic/isp_openbsd.c XS_CMD_S_CLEAR(xs);
xs 535 dev/ic/isp_openbsd.c isp_done(xs);
xs 543 dev/ic/isp_openbsd.c XS_CMD_C_WDOG(xs);
xs 544 dev/ic/isp_openbsd.c timeout_add(&xs->stimeout, _XT(xs));
xs 545 dev/ic/isp_openbsd.c XS_CMD_S_TIMER(xs);
xs 550 dev/ic/isp_openbsd.c XS_CMD_S_GRACE(xs);
xs 555 dev/ic/isp_openbsd.c mp->req_target = XS_CHANNEL(xs) << 7;
xs 591 dev/ic/isp_openbsd.c struct scsi_xfer *xs = arg;
xs 592 dev/ic/isp_openbsd.c struct ispsoftc *isp = XS_ISP(xs);
xs 594 dev/ic/isp_openbsd.c r = isp_start(xs);
xs 598 dev/ic/isp_openbsd.c XS_TGT(xs), XS_LUN(xs));
xs 599 dev/ic/isp_openbsd.c if (xs->timeout) {
xs 600 dev/ic/isp_openbsd.c timeout_set(&xs->stimeout, isp_wdog, isp);
xs 601 dev/ic/isp_openbsd.c timeout_add(&xs->stimeout, _XT(xs));
xs 602 dev/ic/isp_openbsd.c XS_CMD_S_TIMER(xs);
xs 608 dev/ic/isp_openbsd.c isp_add2_blocked_queue(isp, xs);
xs 613 dev/ic/isp_openbsd.c XS_TGT(xs), XS_LUN(xs));
xs 614 dev/ic/isp_openbsd.c timeout_set(&xs->stimeout, isp_requeue, xs);
xs 615 dev/ic/isp_openbsd.c timeout_add(&xs->stimeout, hz);
xs 616 dev/ic/isp_openbsd.c XS_CMD_S_TIMER(xs);
xs 620 dev/ic/isp_openbsd.c if (XS_NOERR(xs))
xs 621 dev/ic/isp_openbsd.c XS_SETERR(xs, XS_DRIVER_STUFFUP);
xs 622 dev/ic/isp_openbsd.c isp_done(xs);
xs 647 dev/ic/isp_openbsd.c struct scsi_xfer *xs = list;
xs 648 dev/ic/isp_openbsd.c list = xs->free_list.le_next;
xs 649 dev/ic/isp_openbsd.c xs->free_list.le_next = NULL;
xs 650 dev/ic/isp_openbsd.c isp_requeue(xs);
xs 671 dev/ic/isp_openbsd.c struct scsi_xfer *xs = list;
xs 672 dev/ic/isp_openbsd.c list = xs->free_list.le_next;
xs 673 dev/ic/isp_openbsd.c xs->free_list.le_next = NULL;
xs 674 dev/ic/isp_openbsd.c isp_requeue(xs);
xs 206 dev/ic/isp_openbsd.h #define XS_CHANNEL(xs) (((xs)->sc_link->flags & SDEV_2NDBUS)? 1 : 0)
xs 207 dev/ic/isp_openbsd.h #define XS_ISP(xs) (xs)->sc_link->adapter_softc
xs 208 dev/ic/isp_openbsd.h #define XS_LUN(xs) ((int) (xs)->sc_link->lun)
xs 209 dev/ic/isp_openbsd.h #define XS_TGT(xs) ((int) (xs)->sc_link->target)
xs 210 dev/ic/isp_openbsd.h #define XS_CDBP(xs) ((caddr_t) (xs)->cmd)
xs 211 dev/ic/isp_openbsd.h #define XS_CDBLEN(xs) (xs)->cmdlen
xs 212 dev/ic/isp_openbsd.h #define XS_XFRLEN(xs) (xs)->datalen
xs 213 dev/ic/isp_openbsd.h #define XS_TIME(xs) (xs)->timeout
xs 214 dev/ic/isp_openbsd.h #define XS_RESID(xs) (xs)->resid
xs 215 dev/ic/isp_openbsd.h #define XS_STSP(xs) (&(xs)->status)
xs 216 dev/ic/isp_openbsd.h #define XS_SNSP(xs) (&(xs)->sense)
xs 217 dev/ic/isp_openbsd.h #define XS_SNSLEN(xs) (sizeof (xs)->sense)
xs 218 dev/ic/isp_openbsd.h #define XS_SNSKEY(xs) ((xs)->sense.flags)
xs 219 dev/ic/isp_openbsd.h #define XS_TAG_P(xs) (((xs)->flags & SCSI_POLL) != 0)
xs 220 dev/ic/isp_openbsd.h #define XS_TAG_TYPE(xs) REQFLAG_STAG
xs 222 dev/ic/isp_openbsd.h #define XS_SETERR(xs, v) (xs)->error = v
xs 234 dev/ic/isp_openbsd.h #define XS_ERR(xs) (xs)->error
xs 236 dev/ic/isp_openbsd.h #define XS_NOERR(xs) (xs)->error == XS_NOERROR
xs 238 dev/ic/isp_openbsd.h #define XS_INITERR(xs) (xs)->error = 0, XS_CMD_S_CLEAR(xs)
xs 240 dev/ic/isp_openbsd.h #define XS_SAVE_SENSE(xs, sp) \
xs 241 dev/ic/isp_openbsd.h if (xs->error == XS_NOERROR) { \
xs 242 dev/ic/isp_openbsd.h xs->error = XS_SENSE; \
xs 244 dev/ic/isp_openbsd.h bcopy(sp->req_sense_data, &(xs)->sense, \
xs 245 dev/ic/isp_openbsd.h imin(XS_SNSLEN(xs), sp->req_sense_len))
xs 329 dev/ic/isp_openbsd.h #define XS_CMD_S_WDOG(xs) (xs)->flags |= XS_PSTS_INWDOG
xs 330 dev/ic/isp_openbsd.h #define XS_CMD_C_WDOG(xs) (xs)->flags &= ~XS_PSTS_INWDOG
xs 331 dev/ic/isp_openbsd.h #define XS_CMD_WDOG_P(xs) (((xs)->flags & XS_PSTS_INWDOG) != 0)
xs 333 dev/ic/isp_openbsd.h #define XS_CMD_S_TIMER(xs) (xs)->flags |= XS_PSTS_TIMED
xs 334 dev/ic/isp_openbsd.h #define XS_CMD_C_TIMER(xs) (xs)->flags &= ~XS_PSTS_TIMED
xs 335 dev/ic/isp_openbsd.h #define XS_CMD_TIMER_P(xs) (((xs)->flags & XS_PSTS_TIMED) != 0)
xs 337 dev/ic/isp_openbsd.h #define XS_CMD_S_GRACE(xs) (xs)->flags |= XS_PSTS_GRACE
xs 338 dev/ic/isp_openbsd.h #define XS_CMD_C_GRACE(xs) (xs)->flags &= ~XS_PSTS_GRACE
xs 339 dev/ic/isp_openbsd.h #define XS_CMD_GRACE_P(xs) (((xs)->flags & XS_PSTS_GRACE) != 0)
xs 341 dev/ic/isp_openbsd.h #define XS_CMD_S_DONE(xs) (xs)->flags |= ITSDONE
xs 342 dev/ic/isp_openbsd.h #define XS_CMD_C_DONE(xs) (xs)->flags &= ~ITSDONE
xs 343 dev/ic/isp_openbsd.h #define XS_CMD_DONE_P(xs) (((xs)->flags & ITSDONE) != 0)
xs 345 dev/ic/isp_openbsd.h #define XS_CMD_S_CLEAR(xs) (xs)->flags &= ~XS_PSTS_ALL
xs 875 dev/ic/isp_target.c void *xs;
xs 880 dev/ic/isp_target.c xs = isp_find_xs(isp, ct->ct_syshandle);
xs 881 dev/ic/isp_target.c if (xs == NULL)
xs 884 dev/ic/isp_target.c xs = NULL;
xs 995 dev/ic/isp_target.c if (xs == NULL) {
xs 1022 dev/ic/isp_target.c ISP_DMAFREE(isp, xs, ct->ct_syshandle);
xs 1035 dev/ic/isp_target.c XS_T *xs;
xs 1040 dev/ic/isp_target.c xs = isp_find_xs(isp, ct->ct_syshandle);
xs 1041 dev/ic/isp_target.c if (xs == NULL)
xs 1044 dev/ic/isp_target.c xs = NULL;
xs 1140 dev/ic/isp_target.c if (xs == NULL) {
xs 1163 dev/ic/isp_target.c ISP_DMAFREE(isp, xs, ct->ct_syshandle);
xs 114 dev/ic/ispvar.h #define ISP_DMASETUP(isp, xs, req, iptrp, optr) \
xs 115 dev/ic/ispvar.h (*(isp)->isp_mdvec->dv_dmaset)((isp), (xs), (req), (iptrp), (optr))
xs 117 dev/ic/ispvar.h #define ISP_DMAFREE(isp, xs, hndl) \
xs 119 dev/ic/ispvar.h (*(isp)->isp_mdvec->dv_dmaclr)((isp), (xs), (hndl))
xs 795 dev/ic/mfi.c mfi_scsi_io(struct mfi_ccb *ccb, struct scsi_xfer *xs, uint32_t blockno,
xs 798 dev/ic/mfi.c struct scsi_link *link = xs->sc_link;
xs 804 dev/ic/mfi.c if (!xs->data)
xs 808 dev/ic/mfi.c if (xs->flags & SCSI_DATA_IN) {
xs 826 dev/ic/mfi.c ccb->ccb_xs = xs;
xs 829 dev/ic/mfi.c ccb->ccb_data = xs->data;
xs 830 dev/ic/mfi.c ccb->ccb_len = xs->datalen;
xs 832 dev/ic/mfi.c if (mfi_create_sgl(ccb, (xs->flags & SCSI_NOSLEEP) ?
xs 842 dev/ic/mfi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 849 dev/ic/mfi.c if (xs->data != NULL) {
xs 854 dev/ic/mfi.c (xs->flags & SCSI_DATA_IN) ?
xs 861 dev/ic/mfi.c xs->error = XS_DRIVER_STUFFUP;
xs 869 dev/ic/mfi.c &xs->sense, ccb->ccb_sense);
xs 870 dev/ic/mfi.c memset(&xs->sense, 0, sizeof(xs->sense));
xs 871 dev/ic/mfi.c memcpy(&xs->sense, ccb->ccb_sense,
xs 873 dev/ic/mfi.c xs->error = XS_SENSE;
xs 877 dev/ic/mfi.c xs->resid = 0;
xs 878 dev/ic/mfi.c xs->flags |= ITSDONE;
xs 881 dev/ic/mfi.c scsi_done(xs);
xs 885 dev/ic/mfi.c mfi_scsi_ld(struct mfi_ccb *ccb, struct scsi_xfer *xs)
xs 887 dev/ic/mfi.c struct scsi_link *link = xs->sc_link;
xs 897 dev/ic/mfi.c pf->mpf_header.mfh_cdb_len = xs->cmdlen;
xs 899 dev/ic/mfi.c pf->mpf_header.mfh_data_len= xs->datalen; /* XXX */
xs 906 dev/ic/mfi.c memcpy(pf->mpf_cdb, &xs->cmdstore, xs->cmdlen);
xs 909 dev/ic/mfi.c ccb->ccb_xs = xs;
xs 913 dev/ic/mfi.c if (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT))
xs 914 dev/ic/mfi.c ccb->ccb_direction = xs->flags & SCSI_DATA_IN ?
xs 919 dev/ic/mfi.c if (xs->data) {
xs 920 dev/ic/mfi.c ccb->ccb_data = xs->data;
xs 921 dev/ic/mfi.c ccb->ccb_len = xs->datalen;
xs 923 dev/ic/mfi.c if (mfi_create_sgl(ccb, (xs->flags & SCSI_NOSLEEP) ?
xs 932 dev/ic/mfi.c mfi_scsi_cmd(struct scsi_xfer *xs)
xs 934 dev/ic/mfi.c struct scsi_link *link = xs->sc_link;
xs 945 dev/ic/mfi.c DEVNAME(sc), xs->cmd->opcode);
xs 959 dev/ic/mfi.c xs->error = XS_NOERROR;
xs 961 dev/ic/mfi.c switch (xs->cmd->opcode) {
xs 965 dev/ic/mfi.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 968 dev/ic/mfi.c if (mfi_scsi_io(ccb, xs, blockno, blockcnt)) {
xs 976 dev/ic/mfi.c rw = (struct scsi_rw *)xs->cmd;
xs 979 dev/ic/mfi.c if (mfi_scsi_io(ccb, xs, blockno, blockcnt)) {
xs 1005 dev/ic/mfi.c if (mfi_scsi_ld(ccb, xs)) {
xs 1014 dev/ic/mfi.c if (xs->flags & SCSI_POLL) {
xs 1020 dev/ic/mfi.c bzero(&xs->sense, sizeof(xs->sense));
xs 1021 dev/ic/mfi.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 1022 dev/ic/mfi.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 1023 dev/ic/mfi.c xs->sense.add_sense_code = 0x20; /* invalid opcode */
xs 1024 dev/ic/mfi.c xs->error = XS_SENSE;
xs 1025 dev/ic/mfi.c xs->flags |= ITSDONE;
xs 1026 dev/ic/mfi.c scsi_done(xs);
xs 1044 dev/ic/mfi.c xs->error = XS_DRIVER_STUFFUP;
xs 1045 dev/ic/mfi.c xs->flags |= ITSDONE;
xs 1046 dev/ic/mfi.c scsi_done(xs);
xs 985 dev/ic/mpi.c mpi_scsi_cmd(struct scsi_xfer *xs)
xs 987 dev/ic/mpi.c struct scsi_link *link = xs->sc_link;
xs 996 dev/ic/mpi.c if (xs->cmdlen > MPI_CDB_LEN) {
xs 998 dev/ic/mpi.c DEVNAME(sc), xs->cmdlen);
xs 999 dev/ic/mpi.c bzero(&xs->sense, sizeof(xs->sense));
xs 1000 dev/ic/mpi.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 1001 dev/ic/mpi.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 1002 dev/ic/mpi.c xs->sense.add_sense_code = 0x20;
xs 1003 dev/ic/mpi.c xs->error = XS_SENSE;
xs 1005 dev/ic/mpi.c scsi_done(xs);
xs 1014 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1016 dev/ic/mpi.c scsi_done(xs);
xs 1021 dev/ic/mpi.c DEVNAME(sc), ccb->ccb_id, xs->flags);
xs 1023 dev/ic/mpi.c ccb->ccb_xs = xs;
xs 1036 dev/ic/mpi.c io->cdb_length = xs->cmdlen;
xs 1037 dev/ic/mpi.c io->sense_buf_len = sizeof(xs->sense);
xs 1044 dev/ic/mpi.c switch (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 1061 dev/ic/mpi.c bcopy(xs->cmd, io->cdb, xs->cmdlen);
xs 1063 dev/ic/mpi.c io->data_length = htole32(xs->datalen);
xs 1069 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1072 dev/ic/mpi.c scsi_done(xs);
xs 1077 dev/ic/mpi.c timeout_set(&xs->stimeout, mpi_timeout_xs, ccb);
xs 1079 dev/ic/mpi.c if (xs->flags & SCSI_POLL) {
xs 1080 dev/ic/mpi.c if (mpi_poll(sc, ccb, xs->timeout) != 0)
xs 1081 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1095 dev/ic/mpi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1100 dev/ic/mpi.c if (xs->datalen != 0) {
xs 1102 dev/ic/mpi.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 1109 dev/ic/mpi.c xs->error = XS_NOERROR;
xs 1110 dev/ic/mpi.c xs->resid = 0;
xs 1111 dev/ic/mpi.c xs->flags |= ITSDONE;
xs 1115 dev/ic/mpi.c xs->status = SCSI_OK;
xs 1117 dev/ic/mpi.c scsi_done(xs);
xs 1124 dev/ic/mpi.c "flags 0x%x\n", DEVNAME(sc), xs->cmd->opcode, xs->datalen,
xs 1125 dev/ic/mpi.c xs->flags);
xs 1148 dev/ic/mpi.c xs->status = sie->scsi_status;
xs 1151 dev/ic/mpi.c xs->resid = xs->datalen - letoh32(sie->transfer_count);
xs 1153 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1159 dev/ic/mpi.c switch (xs->status) {
xs 1161 dev/ic/mpi.c xs->resid = 0;
xs 1165 dev/ic/mpi.c xs->error = XS_SENSE;
xs 1170 dev/ic/mpi.c xs->error = XS_BUSY;
xs 1174 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1181 dev/ic/mpi.c xs->error = XS_BUSY;
xs 1187 dev/ic/mpi.c xs->error = XS_SELTIMEOUT;
xs 1191 dev/ic/mpi.c xs->error = XS_DRIVER_STUFFUP;
xs 1196 dev/ic/mpi.c bcopy(&mcb->mcb_sense, &xs->sense, sizeof(xs->sense));
xs 1199 dev/ic/mpi.c xs->error, xs->status);
xs 1203 dev/ic/mpi.c scsi_done(xs);
xs 1216 dev/ic/mpi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 1226 dev/ic/mpi.c if (xs->datalen == 0) {
xs 1233 dev/ic/mpi.c xs->data, xs->datalen, NULL,
xs 1234 dev/ic/mpi.c (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
xs 1241 dev/ic/mpi.c if (xs->flags & SCSI_DATA_OUT)
xs 1312 dev/ic/mpi.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
xs 150 dev/ic/ncr5380sbc.c #define ncr5380_show_scsi_cmd(xs) /* nada */
xs 151 dev/ic/ncr5380sbc.c #define ncr5380_show_sense(xs) /* nada */
xs 526 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 534 dev/ic/ncr5380sbc.c xs = sr->sr_xs;
xs 535 dev/ic/ncr5380sbc.c if (xs == NULL) {
xs 539 dev/ic/ncr5380sbc.c sc_link = xs->sc_link;
xs 597 dev/ic/ncr5380sbc.c ncr5380_scsi_cmd(xs)
xs 598 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 604 dev/ic/ncr5380sbc.c sc = xs->sc_link->adapter_softc;
xs 605 dev/ic/ncr5380sbc.c flags = xs->flags;
xs 644 dev/ic/ncr5380sbc.c sr->sr_xs = xs;
xs 645 dev/ic/ncr5380sbc.c sr->sr_target = xs->sc_link->target;
xs 646 dev/ic/ncr5380sbc.c sr->sr_lun = xs->sc_link->lun;
xs 648 dev/ic/ncr5380sbc.c sr->sr_dataptr = xs->data;
xs 649 dev/ic/ncr5380sbc.c sr->sr_datalen = xs->datalen;
xs 697 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 707 dev/ic/ncr5380sbc.c xs = sr->sr_xs;
xs 725 dev/ic/ncr5380sbc.c NCR_TRACE("done: aborting, error=%d\n", xs->error);
xs 726 dev/ic/ncr5380sbc.c if (xs->error == XS_NOERROR)
xs 727 dev/ic/ncr5380sbc.c xs->error = XS_TIMEOUT;
xs 730 dev/ic/ncr5380sbc.c NCR_TRACE("done: check error=%d\n", (long) xs->error);
xs 733 dev/ic/ncr5380sbc.c if (xs->error != XS_NOERROR)
xs 743 dev/ic/ncr5380sbc.c ncr5380_show_sense(xs);
xs 746 dev/ic/ncr5380sbc.c xs->error = XS_SENSE;
xs 755 dev/ic/ncr5380sbc.c xs->error = XS_DRIVER_STUFFUP;
xs 770 dev/ic/ncr5380sbc.c xs->error = XS_BUSY;
xs 779 dev/ic/ncr5380sbc.c xs->error = XS_DRIVER_STUFFUP;
xs 785 dev/ic/ncr5380sbc.c NCR_TRACE("done: finish, error=%d\n", xs->error);
xs 809 dev/ic/ncr5380sbc.c xs->flags |= ITSDONE;
xs 810 dev/ic/ncr5380sbc.c scsi_done(xs);
xs 828 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 909 dev/ic/ncr5380sbc.c xs = sr->sr_xs;
xs 917 dev/ic/ncr5380sbc.c xs = sr->sr_xs;
xs 943 dev/ic/ncr5380sbc.c xs->error = error; /* from select */
xs 990 dev/ic/ncr5380sbc.c xs->sc_link->target, xs->sc_link->lun);
xs 991 dev/ic/ncr5380sbc.c ncr5380_show_scsi_cmd(xs);
xs 994 dev/ic/ncr5380sbc.c if (xs->flags & SCSI_RESET) {
xs 1002 dev/ic/ncr5380sbc.c if ((xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) == 0) {
xs 1039 dev/ic/ncr5380sbc.c i = (xs->timeout * hz) / 1000;
xs 1553 dev/ic/ncr5380sbc.c struct scsi_xfer *xs = sr->sr_xs;
xs 1702 dev/ic/ncr5380sbc.c if ((xs->sc_link->quirks & SDEV_AUTOSAVE) == 0)
xs 2015 dev/ic/ncr5380sbc.c struct scsi_xfer *xs = sr->sr_xs;
xs 2024 dev/ic/ncr5380sbc.c rqs.byte2 = xs->sc_link->lun << 5;
xs 2025 dev/ic/ncr5380sbc.c rqs.length = sizeof(xs->sense);
xs 2034 dev/ic/ncr5380sbc.c len = ncr5380_pio_out(sc, PHASE_COMMAND, xs->cmdlen,
xs 2035 dev/ic/ncr5380sbc.c (u_char *)xs->cmd);
xs 2038 dev/ic/ncr5380sbc.c if (len != xs->cmdlen) {
xs 2041 dev/ic/ncr5380sbc.c xs->cmdlen, len);
xs 2042 dev/ic/ncr5380sbc.c ncr5380_show_scsi_cmd(xs);
xs 2046 dev/ic/ncr5380sbc.c xs->error = XS_DRIVER_STUFFUP;
xs 2066 dev/ic/ncr5380sbc.c struct scsi_xfer *xs = sr->sr_xs;
xs 2078 dev/ic/ncr5380sbc.c len = ncr5380_pio_in(sc, phase, sizeof(xs->sense),
xs 2079 dev/ic/ncr5380sbc.c (u_char *)&xs->sense);
xs 2093 dev/ic/ncr5380sbc.c expected_phase = (xs->flags & SCSI_DATA_OUT) ?
xs 2196 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 2207 dev/ic/ncr5380sbc.c xs = sr->sr_xs;
xs 2225 dev/ic/ncr5380sbc.c xs->error = XS_DRIVER_STUFFUP;
xs 2375 dev/ic/ncr5380sbc.c xs->resid = sc->sc_datalen;
xs 2439 dev/ic/ncr5380sbc.c ncr5380_show_scsi_cmd(xs)
xs 2440 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 2442 dev/ic/ncr5380sbc.c u_char *b = (u_char *) xs->cmd;
xs 2445 dev/ic/ncr5380sbc.c if ( ! ( xs->flags & SCSI_RESET ) ) {
xs 2447 dev/ic/ncr5380sbc.c xs->sc_link->scsibus, xs->sc_link->target,
xs 2448 dev/ic/ncr5380sbc.c xs->sc_link->lun);
xs 2449 dev/ic/ncr5380sbc.c while (i < xs->cmdlen) {
xs 2456 dev/ic/ncr5380sbc.c xs->sc_link->scsibus, xs->sc_link->target,
xs 2457 dev/ic/ncr5380sbc.c xs->sc_link->lun);
xs 2463 dev/ic/ncr5380sbc.c ncr5380_show_sense(xs)
xs 2464 dev/ic/ncr5380sbc.c struct scsi_xfer *xs;
xs 2466 dev/ic/ncr5380sbc.c u_char *b = (u_char *)&xs->sense;
xs 2470 dev/ic/ncr5380sbc.c for (i = 0; i < sizeof(xs->sense); i++)
xs 2534 dev/ic/ncr5380sbc.c struct scsi_xfer *xs = sr->sr_xs;
xs 2544 dev/ic/ncr5380sbc.c if (xs == NULL) {
xs 2550 dev/ic/ncr5380sbc.c show_scsi_xs(xs);
xs 2552 dev/ic/ncr5380sbc.c db_printf("xs=%p\n", xs);
xs 410 dev/ic/ncr53c9x.c ecb->xs->error = XS_TIMEOUT;
xs 423 dev/ic/ncr53c9x.c ecb->xs->error = XS_TIMEOUT;
xs 429 dev/ic/ncr53c9x.c ecb->xs->error = XS_TIMEOUT;
xs 597 dev/ic/ncr53c9x.c struct scsi_link *sc_link = ecb->xs->sc_link;
xs 616 dev/ic/ncr53c9x.c if ((ecb->xs->flags & SCSI_POLL) == 0) {
xs 793 dev/ic/ncr53c9x.c ncr53c9x_scsi_cmd(xs)
xs 794 dev/ic/ncr53c9x.c struct scsi_xfer *xs;
xs 796 dev/ic/ncr53c9x.c struct scsi_link *sc_link = xs->sc_link;
xs 805 dev/ic/ncr53c9x.c NCR_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
xs 808 dev/ic/ncr53c9x.c flags = xs->flags;
xs 830 dev/ic/ncr53c9x.c ecb->xs = xs;
xs 831 dev/ic/ncr53c9x.c ecb->timeout = xs->timeout;
xs 838 dev/ic/ncr53c9x.c bcopy(xs->cmd, &ecb->cmd.cmd, xs->cmdlen);
xs 839 dev/ic/ncr53c9x.c ecb->clen = xs->cmdlen;
xs 840 dev/ic/ncr53c9x.c ecb->daddr = xs->data;
xs 841 dev/ic/ncr53c9x.c ecb->dleft = xs->datalen;
xs 858 dev/ic/ncr53c9x.c if (ncr53c9x_poll(sc, xs, ecb->timeout)) {
xs 860 dev/ic/ncr53c9x.c if (ncr53c9x_poll(sc, xs, ecb->timeout))
xs 870 dev/ic/ncr53c9x.c ncr53c9x_poll(sc, xs, count)
xs 872 dev/ic/ncr53c9x.c struct scsi_xfer *xs;
xs 885 dev/ic/ncr53c9x.c if ((xs->flags & ITSDONE) != 0)
xs 928 dev/ic/ncr53c9x.c sc_link = ecb->xs->sc_link;
xs 939 dev/ic/ncr53c9x.c else if (ecb->xs->flags & SCSI_URGENT)
xs 945 dev/ic/ncr53c9x.c if (ecb->xs->flags & SCSI_POLL)
xs 974 dev/ic/ncr53c9x.c sc_link = ecb->xs->sc_link;
xs 1043 dev/ic/ncr53c9x.c struct scsi_xfer *xs = ecb->xs;
xs 1044 dev/ic/ncr53c9x.c struct scsi_link *sc_link = xs->sc_link;
xs 1057 dev/ic/ncr53c9x.c ecb->daddr = (char *)&xs->sense;
xs 1085 dev/ic/ncr53c9x.c struct scsi_xfer *xs = ecb->xs;
xs 1086 dev/ic/ncr53c9x.c struct scsi_link *sc_link = xs->sc_link;
xs 1091 dev/ic/ncr53c9x.c NCR_TRACE(("[ncr53c9x_done(error:%x)] ", xs->error));
xs 1113 dev/ic/ncr53c9x.c if (xs->error == XS_NOERROR) {
xs 1114 dev/ic/ncr53c9x.c xs->status = ecb->stat;
xs 1116 dev/ic/ncr53c9x.c xs->error = XS_TIMEOUT;
xs 1118 dev/ic/ncr53c9x.c xs->error = XS_SENSE;
xs 1121 dev/ic/ncr53c9x.c xs->resid = ecb->dleft;
xs 1125 dev/ic/ncr53c9x.c xs->resid = ecb->dleft;
xs 1129 dev/ic/ncr53c9x.c xs->flags |= ITSDONE;
xs 1133 dev/ic/ncr53c9x.c if (xs->resid != 0)
xs 1134 dev/ic/ncr53c9x.c printf("resid=%lu ", (unsigned long)xs->resid);
xs 1135 dev/ic/ncr53c9x.c if (xs->error == XS_SENSE)
xs 1136 dev/ic/ncr53c9x.c printf("sense=0x%02x\n", xs->sense.error_code);
xs 1138 dev/ic/ncr53c9x.c printf("error=%d\n", xs->error);
xs 1154 dev/ic/ncr53c9x.c if (xs->error == XS_SELTIMEOUT) {
xs 1164 dev/ic/ncr53c9x.c ncr53c9x_free_ecb(sc, ecb, xs->flags);
xs 1166 dev/ic/ncr53c9x.c scsi_done(xs);
xs 1175 dev/ic/ncr53c9x.c &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 1177 dev/ic/ncr53c9x.c int64_t lun = ecb->xs->sc_link->lun;
xs 1520 dev/ic/ncr53c9x.c ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 1526 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 1535 dev/ic/ncr53c9x.c ecb->xs->resid = ecb->dleft;
xs 1549 dev/ic/ncr53c9x.c sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
xs 1555 dev/ic/ncr53c9x.c lun = ecb->xs->sc_link->lun;
xs 1569 dev/ic/ncr53c9x.c sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
xs 1577 dev/ic/ncr53c9x.c sc->sc_dev.dv_xname, ecb->xs->sc_link->target);
xs 1640 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 1665 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 1704 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 1713 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 1825 dev/ic/ncr53c9x.c ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 1839 dev/ic/ncr53c9x.c ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 1853 dev/ic/ncr53c9x.c MSG_IDENTIFY(ecb->xs->sc_link->lun, 0);
xs 1869 dev/ic/ncr53c9x.c ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 2023 dev/ic/ncr53c9x.c ecb->xs->error = XS_TIMEOUT;
xs 2161 dev/ic/ncr53c9x.c ecb->xs->error = XS_SELTIMEOUT;
xs 2164 dev/ic/ncr53c9x.c sc_link = ecb->xs->sc_link;
xs 2185 dev/ic/ncr53c9x.c sc_print_addr(ecb->xs->sc_link);
xs 2188 dev/ic/ncr53c9x.c ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
xs 2216 dev/ic/ncr53c9x.c ecb->xs->error = XS_TIMEOUT;
xs 2374 dev/ic/ncr53c9x.c sc_link = ecb->xs->sc_link;
xs 2523 dev/ic/ncr53c9x.c ecb->xs->resid = ecb->dleft;
xs 2768 dev/ic/ncr53c9x.c struct scsi_xfer *xs = ecb->xs;
xs 2769 dev/ic/ncr53c9x.c struct scsi_link *sc_link = xs->sc_link;
xs 2799 dev/ic/ncr53c9x.c xs->error = XS_TIMEOUT;
xs 107 dev/ic/ncr53c9xvar.h struct scsi_xfer *xs; /* SCSI xfer ctrl block from above */
xs 458 dev/ic/oosiop.c struct scsi_xfer *xs = cb->xs;
xs 466 dev/ic/oosiop.c if (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 475 dev/ic/oosiop.c if (xs->flags & SCSI_DATA_IN) {
xs 492 dev/ic/oosiop.c if (xs->flags & SCSI_DATA_OUT) {
xs 510 dev/ic/oosiop.c if ((xs->flags & SCSI_DATA_IN) == 0) {
xs 514 dev/ic/oosiop.c if ((xs->flags & SCSI_DATA_OUT) == 0) {
xs 717 dev/ic/oosiop.c oosiop_scsicmd(struct scsi_xfer *xs)
xs 724 dev/ic/oosiop.c sc = (struct oosiop_softc *)xs->sc_link->adapter_softc;
xs 731 dev/ic/oosiop.c cb->xs = xs;
xs 732 dev/ic/oosiop.c cb->xsflags = xs->flags;
xs 733 dev/ic/oosiop.c cb->cmdlen = xs->cmdlen;
xs 736 dev/ic/oosiop.c cb->id = xs->sc_link->target;
xs 737 dev/ic/oosiop.c cb->lun = xs->sc_link->lun;
xs 741 dev/ic/oosiop.c err = bus_dmamap_load(sc->sc_dmat, cb->cmddma, xs->cmd,
xs 742 dev/ic/oosiop.c xs->cmdlen, NULL, ((xs->flags & SCSI_NOSLEEP) ?
xs 748 dev/ic/oosiop.c xs->error = XS_DRIVER_STUFFUP;
xs 749 dev/ic/oosiop.c scsi_done(xs);
xs 753 dev/ic/oosiop.c bus_dmamap_sync(sc->sc_dmat, cb->cmddma, 0, xs->cmdlen,
xs 757 dev/ic/oosiop.c if (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 758 dev/ic/oosiop.c cb->datalen = xs->datalen;
xs 760 dev/ic/oosiop.c xs->data, xs->datalen, NULL,
xs 761 dev/ic/oosiop.c ((xs->flags & SCSI_NOSLEEP) ?
xs 764 dev/ic/oosiop.c ((xs->flags & SCSI_DATA_IN) ? BUS_DMA_READ :
xs 769 dev/ic/oosiop.c xs->error = XS_DRIVER_STUFFUP;
xs 771 dev/ic/oosiop.c scsi_done(xs);
xs 776 dev/ic/oosiop.c 0, xs->datalen,
xs 790 dev/ic/oosiop.c timeout_set(&xs->stimeout, oosiop_timeout, cb);
xs 798 dev/ic/oosiop.c if (xs->flags & SCSI_POLL)
xs 802 dev/ic/oosiop.c timeout_add(&xs->stimeout, (xs->timeout / 1000) * hz);
xs 807 dev/ic/oosiop.c if ((xs->flags & ITSDONE) == 0)
xs 816 dev/ic/oosiop.c struct scsi_xfer *xs = cb->xs;
xs 821 dev/ic/oosiop.c to = xs->timeout / 1000;
xs 840 dev/ic/oosiop.c if (xs->flags & ITSDONE)
xs 861 dev/ic/oosiop.c (cb->xs->cmd->opcode != REQUEST_SENSE));
xs 883 dev/ic/oosiop.c struct scsi_xfer *xs;
xs 887 dev/ic/oosiop.c xs = cb->xs;
xs 888 dev/ic/oosiop.c periph = xs->sc_link;
xs 909 dev/ic/oosiop.c timeout_del(&xs->stimeout);
xs 911 dev/ic/oosiop.c xs->status = cb->xfer->status;
xs 914 dev/ic/oosiop.c xs->error = XS_SELTIMEOUT;
xs 916 dev/ic/oosiop.c xs->error = XS_TIMEOUT;
xs 917 dev/ic/oosiop.c else switch (xs->status) {
xs 920 dev/ic/oosiop.c xs->error = XS_NOERROR;
xs 922 dev/ic/oosiop.c xs->error = XS_SENSE;
xs 926 dev/ic/oosiop.c xs->error = XS_BUSY;
xs 934 dev/ic/oosiop.c xs->error = XS_DRIVER_STUFFUP;
xs 938 dev/ic/oosiop.c xs->error = XS_SELTIMEOUT;
xs 942 dev/ic/oosiop.c xs->error = XS_RESET;
xs 949 dev/ic/oosiop.c xs->resid = 0;
xs 950 dev/ic/oosiop.c xs->flags |= ITSDONE;
xs 951 dev/ic/oosiop.c scsi_done(xs);
xs 961 dev/ic/oosiop.c struct scsi_sense *cmd = (struct scsi_sense *)xs->cmd;
xs 966 dev/ic/oosiop.c cmd->byte2 = xs->sc_link->lun << 5;
xs 967 dev/ic/oosiop.c cb->cmdlen = cmd->length = sizeof(xs->sense);
xs 971 dev/ic/oosiop.c cb->datalen = sizeof xs->sense;
xs 980 dev/ic/oosiop.c xs->error = XS_DRIVER_STUFFUP;
xs 988 dev/ic/oosiop.c &xs->sense, sizeof(xs->sense), NULL,
xs 993 dev/ic/oosiop.c xs->error = XS_DRIVER_STUFFUP;
xs 998 dev/ic/oosiop.c 0, sizeof(xs->sense), BUS_DMASYNC_PREREAD);
xs 1003 dev/ic/oosiop.c if ((cb->xs->flags & SCSI_POLL) == 0) {
xs 1005 dev/ic/oosiop.c timeout_add(&xs->stimeout, (xs->timeout / 1000) * hz);
xs 1014 dev/ic/oosiop.c struct scsi_xfer *xs = cb->xs;
xs 1015 dev/ic/oosiop.c struct oosiop_softc *sc = xs->sc_link->adapter_softc;
xs 1018 dev/ic/oosiop.c sc_print_addr(xs->sc_link);
xs 1019 dev/ic/oosiop.c printf("command 0x%02x timeout on xs %p\n", xs->cmd->opcode, xs);
xs 1246 dev/ic/oosiop.c if ((cb->xs->flags & SCSI_POLL) == 0) {
xs 1248 dev/ic/oosiop.c timeout_add(&cb->xs->stimeout,
xs 1249 dev/ic/oosiop.c (cb->xs->timeout / 1000) * hz);
xs 74 dev/ic/oosiopvar.h struct scsi_xfer *xs; /* SCSI xfer ctrl block from above */
xs 97 dev/ic/osiop.c int osiop_scsicmd(struct scsi_xfer *xs);
xs 377 dev/ic/osiop.c osiop_scsicmd(xs)
xs 378 dev/ic/osiop.c struct scsi_xfer *xs;
xs 380 dev/ic/osiop.c struct scsi_link *periph = xs->sc_link;
xs 386 dev/ic/osiop.c if (xs->flags & SCSI_DATA_UIO)
xs 390 dev/ic/osiop.c if (sc->sc_nexus && (xs->flags & SCSI_POLL))
xs 414 dev/ic/osiop.c acb->xs = xs;
xs 415 dev/ic/osiop.c acb->xsflags = xs->flags;
xs 416 dev/ic/osiop.c bcopy(xs->cmd, &acb->ds->scsi_cmd, xs->cmdlen);
xs 417 dev/ic/osiop.c acb->ds->cmd.count = xs->cmdlen;
xs 420 dev/ic/osiop.c acb->data = xs->data;
xs 425 dev/ic/osiop.c acb->datalen = xs->datalen;
xs 427 dev/ic/osiop.c xs->data, acb->datalen, NULL,
xs 434 dev/ic/osiop.c xs->error = XS_DRIVER_STUFFUP;
xs 435 dev/ic/osiop.c scsi_done(xs);
xs 449 dev/ic/osiop.c timeout_set(&xs->stimeout, osiop_timeout, acb);
xs 461 dev/ic/osiop.c timeout_add(&xs->stimeout, (xs->timeout/1000) * hz);
xs 463 dev/ic/osiop.c if ((xs->flags & ITSDONE) == 0)
xs 474 dev/ic/osiop.c struct scsi_xfer *xs = acb->xs;
xs 479 dev/ic/osiop.c to = xs->timeout / 1000;
xs 492 dev/ic/osiop.c xs->sc_link->target,
xs 499 dev/ic/osiop.c acb->ds, acb->xs->timeout);
xs 527 dev/ic/osiop.c if (xs->flags & ITSDONE)
xs 552 dev/ic/osiop.c sc->sc_nexus->xs->sc_link->target : 0,
xs 555 dev/ic/osiop.c TAILQ_FIRST(&sc->ready_list)->xs->sc_link->target :
xs 561 dev/ic/osiop.c periph = acb->xs->sc_link;
xs 592 dev/ic/osiop.c struct scsi_xfer *xs;
xs 598 dev/ic/osiop.c if (acb == NULL || acb->xs == NULL) {
xs 606 dev/ic/osiop.c xs = acb->xs;
xs 608 dev/ic/osiop.c periph = xs->sc_link;
xs 631 dev/ic/osiop.c timeout_del(&xs->stimeout);
xs 632 dev/ic/osiop.c xs->status = status;
xs 637 dev/ic/osiop.c xs->error = XS_NOERROR;
xs 639 dev/ic/osiop.c xs->error = XS_SENSE;
xs 642 dev/ic/osiop.c xs->error = XS_BUSY;
xs 648 dev/ic/osiop.c xs->error = XS_DRIVER_STUFFUP;
xs 660 dev/ic/osiop.c xs->error = XS_SELTIMEOUT;
xs 667 dev/ic/osiop.c xs->error = XS_DRIVER_STUFFUP;
xs 722 dev/ic/osiop.c xs->resid = 0;
xs 723 dev/ic/osiop.c xs->flags |= ITSDONE;
xs 724 dev/ic/osiop.c scsi_done(xs);
xs 733 dev/ic/osiop.c cmd->byte2 = xs->sc_link->lun << 5;
xs 734 dev/ic/osiop.c cmd->length = sizeof(xs->sense);
xs 739 dev/ic/osiop.c acb->datalen = sizeof xs->sense;
xs 741 dev/ic/osiop.c acb->data = &xs->sense;
xs 744 dev/ic/osiop.c &xs->sense, sizeof(xs->sense), NULL,
xs 749 dev/ic/osiop.c xs->error = XS_DRIVER_STUFFUP;
xs 753 dev/ic/osiop.c 0, sizeof(xs->sense), BUS_DMASYNC_PREREAD);
xs 760 dev/ic/osiop.c timeout_add(&xs->stimeout, (xs->timeout/1000) * hz);
xs 918 dev/ic/osiop.c sc->sc_nexus->xs->error =
xs 925 dev/ic/osiop.c acb->xs->error = (acb->flags & ACB_F_TIMEOUT) ?
xs 965 dev/ic/osiop.c struct scsi_xfer *xs = acb->xs;
xs 968 dev/ic/osiop.c int target = xs->sc_link->target;
xs 969 dev/ic/osiop.c int lun = xs->sc_link->lun;
xs 1179 dev/ic/osiop.c target = acb->xs->sc_link->target;
xs 1220 dev/ic/osiop.c target = acb->xs->sc_link->target;
xs 1374 dev/ic/osiop.c acb->xs->error = XS_SELTIMEOUT;
xs 1381 dev/ic/osiop.c target = acb->xs->sc_link->target;
xs 1562 dev/ic/osiop.c sc->sc_nexus->xs->sc_link;
xs 1579 dev/ic/osiop.c struct scsi_link *periph = acb->xs->sc_link;
xs 1638 dev/ic/osiop.c target = sc->sc_nexus->xs->sc_link->target;
xs 1758 dev/ic/osiop.c acb->xs->sc_link->target,
xs 1831 dev/ic/osiop.c periph = sc->sc_nexus->xs->sc_link;
xs 1974 dev/ic/osiop.c struct scsi_xfer *xs = acb->xs;
xs 1978 dev/ic/osiop.c sc_print_addr(xs->sc_link);
xs 1979 dev/ic/osiop.c printf("command 0x%02x timeout on xs %p\n", xs->cmd->opcode, xs);
xs 2018 dev/ic/osiop.c if (acb->xs == NULL) {
xs 2025 dev/ic/osiop.c acb->xs->sc_link->target,
xs 2026 dev/ic/osiop.c acb->xs->sc_link->lun,
xs 2032 dev/ic/osiop.c printf(" xs: %p data %p:%04x ", acb->xs, acb->data,
xs 143 dev/ic/osiopvar.h struct scsi_xfer *xs; /* SCSI xfer ctrl block from upper layer */
xs 358 dev/ic/siop.c struct scsi_xfer *xs;
xs 397 dev/ic/siop.c xs = siop_cmd->cmd_c.xs;
xs 399 dev/ic/siop.c target = siop_cmd->cmd_c.xs->sc_link->target;
xs 400 dev/ic/siop.c lun = siop_cmd->cmd_c.xs->sc_link->lun;
xs 409 dev/ic/siop.c xs = NULL;
xs 423 dev/ic/siop.c xs = NULL;
xs 509 dev/ic/siop.c sc_print_addr(xs->sc_link);
xs 575 dev/ic/siop.c sc_print_addr(xs->sc_link);
xs 585 dev/ic/siop.c xs->error = XS_SELTIMEOUT;
xs 638 dev/ic/siop.c xs->error = XS_SELTIMEOUT;
xs 675 dev/ic/siop.c xs = NULL;
xs 683 dev/ic/siop.c if (xs) {
xs 684 dev/ic/siop.c xs->error = XS_SELTIMEOUT;
xs 756 dev/ic/siop.c if (xs)
xs 757 dev/ic/siop.c sc_print_addr(xs->sc_link);
xs 817 dev/ic/siop.c if (xs)
xs 818 dev/ic/siop.c sc_print_addr(xs->sc_link);
xs 842 dev/ic/siop.c if (xs)
xs 843 dev/ic/siop.c sc_print_addr(xs->sc_link);
xs 1012 dev/ic/siop.c if (xs == NULL) {
xs 1050 dev/ic/siop.c if (xs) {
xs 1051 dev/ic/siop.c xs->error = XS_SELTIMEOUT;
xs 1073 dev/ic/siop.c xs->status = siop_ctoh32(&sc->sc_c, siop_cmd->cmd_tables->status);
xs 1074 dev/ic/siop.c if (xs->status == SCSI_OK)
xs 1092 dev/ic/siop.c struct scsi_xfer *xs = siop_cmd->cmd_c.xs;
xs 1095 dev/ic/siop.c ((struct siop_target*)sc->sc_c.targets[xs->sc_link->target])->siop_lun[xs->sc_link->lun];
xs 1101 dev/ic/siop.c timeout_del(&siop_cmd->cmd_c.xs->stimeout);
xs 1103 dev/ic/siop.c switch(xs->status) {
xs 1105 dev/ic/siop.c xs->error = (siop_cmd->cmd_c.status == CMDST_DONE) ?
xs 1109 dev/ic/siop.c xs->error = XS_BUSY;
xs 1116 dev/ic/siop.c xs->error = XS_DRIVER_STUFFUP;
xs 1133 dev/ic/siop.c xs->sc_link->target,
xs 1134 dev/ic/siop.c xs->sc_link->lun, siop_cmd->cmd_c.tag);
xs 1152 dev/ic/siop.c xs->error = XS_SELTIMEOUT;
xs 1155 dev/ic/siop.c xs->error = XS_DRIVER_STUFFUP;
xs 1158 dev/ic/siop.c xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 1161 dev/ic/siop.c (xs->flags & SCSI_DATA_IN) ?
xs 1173 dev/ic/siop.c cmd->byte2 = xs->sc_link->lun << 5;
xs 1179 dev/ic/siop.c &xs->sense, sizeof(struct scsi_sense_data),
xs 1185 dev/ic/siop.c xs->error = XS_DRIVER_STUFFUP;
xs 1205 dev/ic/siop.c xs->flags |= ITSDONE;
xs 1209 dev/ic/siop.c if (xs->resid != 0)
xs 1210 dev/ic/siop.c printf("resid %d datalen %d\n", xs->resid, xs->datalen);
xs 1212 dev/ic/siop.c scsi_done(xs);
xs 1224 dev/ic/siop.c int target = siop_cmd->cmd_c.xs->sc_link->target;
xs 1225 dev/ic/siop.c int lun = siop_cmd->cmd_c.xs->sc_link->lun;
xs 1303 dev/ic/siop.c sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
xs 1322 dev/ic/siop.c sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
xs 1332 dev/ic/siop.c sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
xs 1341 dev/ic/siop.c siop_cmd->cmd_c.xs->error =
xs 1344 dev/ic/siop.c siop_cmd->cmd_c.xs->status = SCSI_SIOP_NOCHECK;
xs 1345 dev/ic/siop.c sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
xs 1354 dev/ic/siop.c siop_cmd->cmd_c.status, siop_cmd->cmd_c.xs->error);
xs 1361 dev/ic/siop.c siop_scsicmd(xs)
xs 1362 dev/ic/siop.c struct scsi_xfer *xs;
xs 1364 dev/ic/siop.c struct siop_softc *sc = (struct siop_softc *)xs->sc_link->adapter_softc;
xs 1368 dev/ic/siop.c const int target = xs->sc_link->target;
xs 1369 dev/ic/siop.c const int lun = xs->sc_link->lun;
xs 1383 dev/ic/siop.c timeout_set(&xs->stimeout, siop_timeout, siop_cmd);
xs 1441 dev/ic/siop.c siop_cmd->cmd_c.xs = xs;
xs 1447 dev/ic/siop.c bcopy(xs->cmd, &siop_cmd->cmd_c.siop_tables->xscmd, xs->cmdlen);
xs 1449 dev/ic/siop.c siop_htoc32(&sc->sc_c, xs->cmdlen);
xs 1452 dev/ic/siop.c if (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 1454 dev/ic/siop.c siop_cmd->cmd_c.dmamap_data, xs->data, xs->datalen,
xs 1456 dev/ic/siop.c ((xs->flags & SCSI_DATA_IN) ?
xs 1467 dev/ic/siop.c (xs->flags & SCSI_DATA_IN) ?
xs 1479 dev/ic/siop.c if (((xs->flags & SCSI_POLL) == 0) &&
xs 1484 dev/ic/siop.c if ((xs->flags & SCSI_POLL) == 0) {
xs 1490 dev/ic/siop.c for(i = xs->timeout; i > 0; i--) {
xs 1492 dev/ic/siop.c if ((xs->flags & ITSDONE) == 0) {
xs 1496 dev/ic/siop.c if (xs->cmd->opcode == INQUIRY && xs->error == XS_NOERROR) {
xs 1498 dev/ic/siop.c (struct scsi_inquiry_data *)xs->data;
xs 1528 dev/ic/siop.c while ((xs->flags & ITSDONE) == 0)
xs 1588 dev/ic/siop.c target = siop_cmd->cmd_c.xs->sc_link->target;
xs 1589 dev/ic/siop.c lun = siop_cmd->cmd_c.xs->sc_link->lun;
xs 1653 dev/ic/siop.c if (siop_cmd->cmd_c.xs->bp != NULL &&
xs 1654 dev/ic/siop.c (siop_cmd->cmd_c.xs->bp->b_flags & B_ASYNC))
xs 1698 dev/ic/siop.c if ((siop_cmd->cmd_c.xs->flags & SCSI_POLL) == 0) {
xs 1700 dev/ic/siop.c timeout = (u_int64_t) siop_cmd->cmd_c.xs->timeout *
xs 1704 dev/ic/siop.c timeout_add(&siop_cmd->cmd_c.xs->stimeout, timeout);
xs 1747 dev/ic/siop.c timeout_del(&siop_cmd->cmd_c.xs->stimeout);
xs 1749 dev/ic/siop.c sc_print_addr(siop_cmd->cmd_c.xs->sc_link);
xs 1751 dev/ic/siop.c siop_cmd->cmd_c.xs->cmd->opcode);
xs 244 dev/ic/siop_common.c struct scsi_xfer *xs = siop_cmd->xs;
xs 245 dev/ic/siop_common.c int target = xs->sc_link->target;
xs 246 dev/ic/siop_common.c int lun = xs->sc_link->lun;
xs 273 dev/ic/siop_common.c quirks = xs->sc_link->quirks;
xs 319 dev/ic/siop_common.c if ((xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) ||
xs 340 dev/ic/siop_common.c int target = siop_cmd->xs->sc_link->target;
xs 420 dev/ic/siop_common.c int target = siop_cmd->xs->sc_link->target;
xs 534 dev/ic/siop_common.c int target = siop_cmd->xs->sc_link->target;
xs 731 dev/ic/siop_common.c if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
xs 747 dev/ic/siop_common.c if (siop_cmd->xs->flags & SCSI_DATA_OUT) {
xs 794 dev/ic/siop_common.c if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
xs 807 dev/ic/siop_common.c sc_print_addr(siop_cmd->xs->sc_link);
xs 857 dev/ic/siop_common.c if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
xs 866 dev/ic/siop_common.c siop_cmd->xs->resid -=
xs 875 dev/ic/siop_common.c siop_cmd->xs->resid -=
xs 85 dev/ic/siopvar_common.h struct scsi_xfer *xs; /* xfer from the upper level */
xs 330 dev/ic/trm.c trm_scsi_cmd(struct scsi_xfer *xs)
xs 340 dev/ic/trm.c target = xs->sc_link->target;
xs 341 dev/ic/trm.c lun = xs->sc_link->lun;
xs 343 dev/ic/trm.c sc = (struct trm_softc *)xs->sc_link->adapter_softc;
xs 348 dev/ic/trm.c if ((xs->flags & SCSI_POLL) != 0)
xs 350 dev/ic/trm.c sc->sc_device.dv_xname, sc, xs, target, lun, xs->cmd->opcode);
xs 356 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 362 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 369 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 373 dev/ic/trm.c xferflags = xs->flags;
xs 379 dev/ic/trm.c xs->error = XS_NOERROR;
xs 387 dev/ic/trm.c xs->flags &= ~ITSDONE;
xs 390 dev/ic/trm.c xs->error = XS_NOERROR;
xs 391 dev/ic/trm.c xs->status = SCSI_OK;
xs 392 dev/ic/trm.c xs->resid = 0;
xs 406 dev/ic/trm.c if (xs->datalen != 0) {
xs 409 dev/ic/trm.c (u_int32_t)xs->datalen);
xs 415 dev/ic/trm.c (u_int32_t)xs->data);
xs 418 dev/ic/trm.c xs->data, xs->datalen, NULL,
xs 423 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 443 dev/ic/trm.c pSRB->SRBTotalXferLength = xs->datalen;
xs 448 dev/ic/trm.c pSRB->xs = xs;
xs 449 dev/ic/trm.c pSRB->ScsiCmdLen = xs->cmdlen;
xs 451 dev/ic/trm.c memcpy(pSRB->CmdBlock, xs->cmd, xs->cmdlen);
xs 455 dev/ic/trm.c timeout_set(&xs->stimeout, trm_timeout, pSRB);
xs 464 dev/ic/trm.c timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
xs 469 dev/ic/trm.c while ((--xs->timeout > 0) && ((xs->flags & ITSDONE) == 0)) {
xs 474 dev/ic/trm.c if (xs->timeout == 0)
xs 647 dev/ic/trm.c struct scsi_xfer *xs;
xs 651 dev/ic/trm.c xs = pSRB->xs;
xs 653 dev/ic/trm.c if (xs != NULL) {
xs 654 dev/ic/trm.c sc = xs->sc_link->adapter_softc;
xs 655 dev/ic/trm.c sc_print_addr(xs->sc_link);
xs 657 dev/ic/trm.c sc->sc_device.dv_xname, xs->cmd->opcode,
xs 658 dev/ic/trm.c xs->sc_link->target, xs->sc_link->lun);
xs 719 dev/ic/trm.c if (((pSRB->xs->flags & SCSI_POLL) != 0) ||
xs 1819 dev/ic/trm.c if ((pSRB->xs->flags & SCSI_POLL) == 0) {
xs 1950 dev/ic/trm.c struct scsi_xfer *xs = pSRB->xs;
xs 1960 dev/ic/trm.c if (xs == NULL) {
xs 1965 dev/ic/trm.c timeout_del(&xs->stimeout);
xs 1967 dev/ic/trm.c xs->status = pSRB->TargetStatus;
xs 1969 dev/ic/trm.c switch (xs->status) {
xs 1981 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 1984 dev/ic/trm.c xs->error = XS_TIMEOUT;
xs 1988 dev/ic/trm.c s2 = &xs->sense;
xs 1992 dev/ic/trm.c xs->status = SCSI_CHECK;
xs 1993 dev/ic/trm.c xs->error = XS_SENSE;
xs 1996 dev/ic/trm.c xs->error = XS_NOERROR;
xs 2004 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 2012 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 2021 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 2036 dev/ic/trm.c xs->error = XS_BUSY;
xs 2040 dev/ic/trm.c xs->status = SCSI_OK;
xs 2041 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 2045 dev/ic/trm.c xs->status = SCSI_OK;
xs 2046 dev/ic/trm.c xs->error = XS_RESET;
xs 2050 dev/ic/trm.c xs->status = SCSI_OK;
xs 2051 dev/ic/trm.c xs->error = XS_SELTIMEOUT;
xs 2055 dev/ic/trm.c xs->error = XS_DRIVER_STUFFUP;
xs 2059 dev/ic/trm.c target = xs->sc_link->target;
xs 2060 dev/ic/trm.c lun = xs->sc_link->lun;
xs 2062 dev/ic/trm.c if ((xs->flags & SCSI_POLL) != 0) {
xs 2064 dev/ic/trm.c if (xs->cmd->opcode == INQUIRY) {
xs 2066 dev/ic/trm.c ptr = (struct scsi_inquiry_data *) xs->data;
xs 2068 dev/ic/trm.c if ((xs->error != XS_NOERROR) ||
xs 2079 dev/ic/trm.c pDCB->sc_link = xs->sc_link;
xs 2085 dev/ic/trm.c xs->flags |= ITSDONE;
xs 2091 dev/ic/trm.c if ((xs->error != 0) || (xs->status != 0) || ((xs->flags & SCSI_POLL) != 0))
xs 2093 dev/ic/trm.c sc->sc_device.dv_xname, target, lun, xs->cmd->opcode, xs->error, xs->status);
xs 2096 dev/ic/trm.c scsi_done(xs);
xs 2109 dev/ic/trm.c struct scsi_xfer *xs = pSRB->xs;
xs 2119 dev/ic/trm.c if (xs != NULL) {
xs 2120 dev/ic/trm.c timeout_del(&xs->stimeout);
xs 2122 dev/ic/trm.c if (xs->datalen != 0) {
xs 2125 dev/ic/trm.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
xs 2155 dev/ic/trm.c pSRB->xs = NULL;
xs 2280 dev/ic/trm.c pSRB->CmdBlock[1] = (pSRB->xs->sc_link->lun) << 5;
xs 2285 dev/ic/trm.c if ((pSRB->xs != NULL) && ((pSRB->xs->flags & SCSI_POLL) == 0))
xs 2286 dev/ic/trm.c timeout_add(&pSRB->xs->stimeout, (pSRB->xs->timeout/1000) * hz);
xs 134 dev/ic/trm.h struct scsi_xfer *xs;
xs 84 dev/ic/twe.c void twe_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size);
xs 649 dev/ic/twe.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 652 dev/ic/twe.c for (i = 100 * (xs? xs->timeout : 35000); i--; DELAY(10)) {
xs 690 dev/ic/twe.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 703 dev/ic/twe.c if (xs) {
xs 704 dev/ic/twe.c if (xs->cmd->opcode != PREVENT_ALLOW &&
xs 705 dev/ic/twe.c xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 707 dev/ic/twe.c dmap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
xs 740 dev/ic/twe.c if (xs) {
xs 741 dev/ic/twe.c xs->resid = 0;
xs 742 dev/ic/twe.c xs->flags |= ITSDONE;
xs 743 dev/ic/twe.c scsi_done(xs);
xs 760 dev/ic/twe.c twe_copy_internal_data(xs, v, size)
xs 761 dev/ic/twe.c struct scsi_xfer *xs;
xs 769 dev/ic/twe.c if (!xs->datalen)
xs 772 dev/ic/twe.c copy_cnt = MIN(size, xs->datalen);
xs 773 dev/ic/twe.c bcopy(v, xs->data, copy_cnt);
xs 778 dev/ic/twe.c twe_scsi_cmd(xs)
xs 779 dev/ic/twe.c struct scsi_xfer *xs;
xs 781 dev/ic/twe.c struct scsi_link *link = xs->sc_link;
xs 798 dev/ic/twe.c xs->error = XS_DRIVER_STUFFUP;
xs 804 dev/ic/twe.c xs->error = XS_NOERROR;
xs 806 dev/ic/twe.c switch (xs->cmd->opcode) {
xs 812 dev/ic/twe.c TWE_DPRINTF(TWE_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
xs 824 dev/ic/twe.c twe_copy_internal_data(xs, &sd, sizeof sd);
xs 842 dev/ic/twe.c twe_copy_internal_data(xs, &inq, sizeof inq);
xs 850 dev/ic/twe.c twe_copy_internal_data(xs, &rcd, sizeof rcd);
xs 865 dev/ic/twe.c if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
xs 867 dev/ic/twe.c if (xs->cmdlen == 6) {
xs 868 dev/ic/twe.c rw = (struct scsi_rw *)xs->cmd;
xs 873 dev/ic/twe.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 877 dev/ic/twe.c if (xs->cmd->opcode == WRITE_BIG &&
xs 886 dev/ic/twe.c xs->error = XS_DRIVER_STUFFUP;
xs 887 dev/ic/twe.c scsi_done(xs);
xs 893 dev/ic/twe.c switch (xs->cmd->opcode) {
xs 902 dev/ic/twe.c xs->error = XS_DRIVER_STUFFUP;
xs 903 dev/ic/twe.c scsi_done(xs);
xs 908 dev/ic/twe.c ccb->ccb_xs = xs;
xs 909 dev/ic/twe.c ccb->ccb_data = xs->data;
xs 910 dev/ic/twe.c ccb->ccb_length = xs->datalen;
xs 918 dev/ic/twe.c wait = xs->flags & SCSI_POLL;
xs 922 dev/ic/twe.c if ((error = twe_cmd(ccb, ((xs->flags & SCSI_NOSLEEP)?
xs 926 dev/ic/twe.c TWE_DPRINTF(TWE_D_CMD, ("failed %p ", xs));
xs 927 dev/ic/twe.c if (xs->flags & SCSI_POLL) {
xs 930 dev/ic/twe.c xs->error = XS_DRIVER_STUFFUP;
xs 931 dev/ic/twe.c scsi_done(xs);
xs 945 dev/ic/twe.c xs->cmd->opcode, target));
xs 946 dev/ic/twe.c xs->error = XS_DRIVER_STUFFUP;
xs 294 dev/ic/uha.c struct scsi_xfer *xs = mscp->xs;
xs 296 dev/ic/uha.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("uha_done\n"));
xs 306 dev/ic/uha.c if (xs->error == XS_NOERROR) {
xs 310 dev/ic/uha.c xs->error = XS_SELTIMEOUT;
xs 315 dev/ic/uha.c xs->error = XS_DRIVER_STUFFUP;
xs 321 dev/ic/uha.c s2 = &xs->sense;
xs 323 dev/ic/uha.c xs->error = XS_SENSE;
xs 326 dev/ic/uha.c xs->error = XS_BUSY;
xs 331 dev/ic/uha.c xs->error = XS_DRIVER_STUFFUP;
xs 334 dev/ic/uha.c xs->resid = 0;
xs 337 dev/ic/uha.c xs->flags |= ITSDONE;
xs 338 dev/ic/uha.c scsi_done(xs);
xs 356 dev/ic/uha.c uha_scsi_cmd(xs)
xs 357 dev/ic/uha.c struct scsi_xfer *xs;
xs 359 dev/ic/uha.c struct scsi_link *sc_link = xs->sc_link;
xs 374 dev/ic/uha.c flags = xs->flags;
xs 378 dev/ic/uha.c mscp->xs = xs;
xs 379 dev/ic/uha.c mscp->timeout = xs->timeout;
xs 380 dev/ic/uha.c timeout_set(&xs->stimeout, uha_timeout, xs);
xs 392 dev/ic/uha.c bcopy(xs->cmd, &mscp->scsi_cmd, mscp->scsi_cmd_length);
xs 399 dev/ic/uha.c mscp->scsi_cmd_length = xs->cmdlen;
xs 405 dev/ic/uha.c if (xs->datalen) {
xs 411 dev/ic/uha.c iovp = ((struct uio *) xs->data)->uio_iov;
xs 412 dev/ic/uha.c datalen = ((struct uio *) xs->data)->uio_iovcnt;
xs 413 dev/ic/uha.c xs->datalen = 0;
xs 417 dev/ic/uha.c xs->datalen += iovp->iov_len;
xs 432 dev/ic/uha.c ("%d @0x%x:- ", xs->datalen, xs->data));
xs 433 dev/ic/uha.c datalen = xs->datalen;
xs 434 dev/ic/uha.c thiskv = (int) xs->data;
xs 488 dev/ic/uha.c mscp->data_length = xs->datalen;
xs 513 dev/ic/uha.c if ((sc->poll)(sc, xs, mscp->timeout)) {
xs 515 dev/ic/uha.c if ((sc->poll)(sc, xs, mscp->timeout))
xs 521 dev/ic/uha.c xs->error = XS_DRIVER_STUFFUP;
xs 531 dev/ic/uha.c struct scsi_xfer *xs = mscp->xs;
xs 532 dev/ic/uha.c struct scsi_link *sc_link = xs->sc_link;
xs 548 dev/ic/uha.c mscp->xs->error = XS_TIMEOUT;
xs 224 dev/ic/uhareg.h struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 85 dev/isa/aha.c #define VOLATILE_XS(xs) \
xs 86 dev/isa/aha.c ((xs)->datalen > 0 && (xs)->bp == NULL && \
xs 87 dev/isa/aha.c ((xs)->flags & SCSI_POLL) == 0)
xs 89 dev/isa/aha.c #define VOLATILE_XS(xs) 0
xs 498 dev/isa/aha.c if ((ccb->xs->flags & SCSI_POLL) == 0)
xs 499 dev/isa/aha.c timeout_del(&ccb->xs->stimeout);
xs 817 dev/isa/aha.c if ((ccb->xs->flags & SCSI_POLL) == 0) {
xs 818 dev/isa/aha.c timeout_set(&ccb->xs->stimeout, aha_timeout, ccb);
xs 819 dev/isa/aha.c timeout_add(&ccb->xs->stimeout, (ccb->timeout * hz) / 1000);
xs 840 dev/isa/aha.c struct scsi_xfer *xs = ccb->xs;
xs 842 dev/isa/aha.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("aha_done\n"));
xs 861 dev/isa/aha.c if (xs->error == XS_NOERROR) {
xs 865 dev/isa/aha.c xs->error = XS_SELTIMEOUT;
xs 870 dev/isa/aha.c xs->error = XS_DRIVER_STUFFUP;
xs 879 dev/isa/aha.c s2 = &xs->sense;
xs 881 dev/isa/aha.c xs->error = XS_SENSE;
xs 884 dev/isa/aha.c xs->error = XS_BUSY;
xs 889 dev/isa/aha.c xs->error = XS_DRIVER_STUFFUP;
xs 893 dev/isa/aha.c xs->resid = 0;
xs 895 dev/isa/aha.c xs->flags |= ITSDONE;
xs 897 dev/isa/aha.c if (VOLATILE_XS(xs)) {
xs 903 dev/isa/aha.c if (xs->flags & SCSI_DATA_IN)
xs 906 dev/isa/aha.c if (xs->flags & SCSI_DATA_OUT)
xs 912 dev/isa/aha.c scsi_done(xs);
xs 1256 dev/isa/aha.c aha_scsi_cmd(xs)
xs 1257 dev/isa/aha.c struct scsi_xfer *xs;
xs 1259 dev/isa/aha.c struct scsi_link *sc_link = xs->sc_link;
xs 1276 dev/isa/aha.c flags = xs->flags;
xs 1280 dev/isa/aha.c ccb->xs = xs;
xs 1281 dev/isa/aha.c ccb->timeout = xs->timeout;
xs 1292 dev/isa/aha.c (xs->datalen ? AHA_INIT_SCAT_GATH_CCB : AHA_INITIATOR_CCB);
xs 1293 dev/isa/aha.c bcopy(xs->cmd, &ccb->scsi_cmd,
xs 1294 dev/isa/aha.c ccb->scsi_cmd_length = xs->cmdlen);
xs 1297 dev/isa/aha.c if (xs->datalen) {
xs 1302 dev/isa/aha.c iovp = ((struct uio *)xs->data)->uio_iov;
xs 1303 dev/isa/aha.c datalen = ((struct uio *)xs->data)->uio_iovcnt;
xs 1304 dev/isa/aha.c xs->datalen = 0;
xs 1308 dev/isa/aha.c xs->datalen += iovp->iov_len;
xs 1322 dev/isa/aha.c if (bus_dmamap_load(sc->sc_dmat, ccb->dmam, xs->data,
xs 1323 dev/isa/aha.c xs->datalen, NULL, BUS_DMA_NOWAIT) != 0) {
xs 1325 dev/isa/aha.c xs->error = XS_DRIVER_STUFFUP;
xs 1370 dev/isa/aha.c if (VOLATILE_XS(xs)) {
xs 1371 dev/isa/aha.c while ((ccb->xs->flags & ITSDONE) == 0) {
xs 1386 dev/isa/aha.c scsi_done(xs);
xs 1398 dev/isa/aha.c if (aha_poll(sc, xs, ccb->timeout)) {
xs 1400 dev/isa/aha.c if (aha_poll(sc, xs, ccb->timeout))
xs 1410 dev/isa/aha.c aha_poll(sc, xs, count)
xs 1412 dev/isa/aha.c struct scsi_xfer *xs;
xs 1429 dev/isa/aha.c if (xs->flags & ITSDONE)
xs 1442 dev/isa/aha.c struct scsi_xfer *xs;
xs 1450 dev/isa/aha.c xs = ccb->xs;
xs 1451 dev/isa/aha.c sc_link = xs->sc_link;
xs 1480 dev/isa/aha.c ccb->xs->error = XS_TIMEOUT;
xs 124 dev/isa/ahareg.h struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 177 dev/isa/seagate.c struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
xs 536 dev/isa/seagate.c sea_scsi_cmd(struct scsi_xfer *xs)
xs 538 dev/isa/seagate.c struct scsi_link *sc_link = xs->sc_link;
xs 546 dev/isa/seagate.c flags = xs->flags;
xs 549 dev/isa/seagate.c xs->flags &= ~ITSDONE;
xs 555 dev/isa/seagate.c scb->xs = xs;
xs 563 dev/isa/seagate.c xs->error = XS_DRIVER_STUFFUP;
xs 570 dev/isa/seagate.c scb->datalen = xs->datalen;
xs 571 dev/isa/seagate.c scb->data = xs->data;
xs 585 dev/isa/seagate.c timeout_set(&scb->xs->stimeout, sea_timeout, scb);
xs 586 dev/isa/seagate.c timeout_add(&scb->xs->stimeout, (xs->timeout * hz) / 1000);
xs 596 dev/isa/seagate.c if (sea_poll(sea, xs, xs->timeout)) {
xs 598 dev/isa/seagate.c if (sea_poll(sea, xs, 2000))
xs 697 dev/isa/seagate.c if (!(sea->busy[scb->xs->sc_link->target] &
xs 698 dev/isa/seagate.c (1 << scb->xs->sc_link->lun))) {
xs 789 dev/isa/seagate.c struct scsi_xfer *xs = scb->xs;
xs 790 dev/isa/seagate.c struct scsi_link *sc_link = xs->sc_link;
xs 807 dev/isa/seagate.c scb->xs->retries = 0;
xs 816 dev/isa/seagate.c if ((xs->flags & SCSI_POLL) == 0) {
xs 817 dev/isa/seagate.c timeout_set(&scb->xs->stimeout, sea_timeout, scb);
xs 818 dev/isa/seagate.c timeout_add(&scb->xs->stimeout, 2 * hz);
xs 887 dev/isa/seagate.c if (target_mask == (1 << scb->xs->sc_link->target) &&
xs 888 dev/isa/seagate.c lun == scb->xs->sc_link->lun) {
xs 1032 dev/isa/seagate.c DATA = (u_char)((1 << scb->xs->sc_link->target) | sea->our_id_mask);
xs 1074 dev/isa/seagate.c msg[0] = MSG_IDENTIFY(scb->xs->sc_link->lun, 1);
xs 1086 dev/isa/seagate.c sea->busy[scb->xs->sc_link->target] |= 1 << scb->xs->sc_link->lun;
xs 1156 dev/isa/seagate.c struct scsi_xfer *xs = scb->xs;
xs 1158 dev/isa/seagate.c timeout_del(&scb->xs->stimeout);
xs 1160 dev/isa/seagate.c xs->resid = scb->datalen;
xs 1164 dev/isa/seagate.c xs->resid = 0;
xs 1167 dev/isa/seagate.c xs->error = XS_TIMEOUT;
xs 1169 dev/isa/seagate.c xs->error = XS_DRIVER_STUFFUP;
xs 1171 dev/isa/seagate.c xs->flags |= ITSDONE;
xs 1172 dev/isa/seagate.c sea_free_scb(sea, scb, xs->flags);
xs 1173 dev/isa/seagate.c scsi_done(xs);
xs 1180 dev/isa/seagate.c sea_poll(struct sea_softc *sea, struct scsi_xfer *xs, int count)
xs 1190 dev/isa/seagate.c if (xs->flags & ITSDONE)
xs 1342 dev/isa/seagate.c sea->busy[scb->xs->sc_link->target] &=
xs 1343 dev/isa/seagate.c ~(1 << scb->xs->sc_link->lun);
xs 1384 dev/isa/seagate.c sea->busy[scb->xs->sc_link->target] &=
xs 1385 dev/isa/seagate.c ~(1 << scb->xs->sc_link->lun);
xs 1396 dev/isa/seagate.c len = scb->xs->cmdlen;
xs 1397 dev/isa/seagate.c data = (char *) scb->xs->cmd;
xs 1404 dev/isa/seagate.c scb->xs->status = tmp;
xs 271 dev/isa/uha_isa.c if ((mscp->xs->flags & SCSI_POLL) == 0)
xs 272 dev/isa/uha_isa.c timeout_add(&mscp->xs->stimeout, (mscp->timeout * hz) / 1000);
xs 281 dev/isa/uha_isa.c u14_poll(sc, xs, count)
xs 283 dev/isa/uha_isa.c struct scsi_xfer *xs;
xs 296 dev/isa/uha_isa.c if (xs->flags & ITSDONE)
xs 349 dev/isa/uha_isa.c timeout_del(&mscp->xs->stimeout);
xs 383 dev/isa/wds.c timeout_del(&scb->xs->stimeout);
xs 743 dev/isa/wds.c timeout_set(&scb->xs->stimeout, wds_timeout, scb);
xs 744 dev/isa/wds.c timeout_add(&scb->xs->stimeout, (scb->timeout * hz) / 1000);
xs 763 dev/isa/wds.c struct scsi_xfer *xs = scb->xs;
xs 768 dev/isa/wds.c if (xs == 0) {
xs 774 dev/isa/wds.c if (xs->error == XS_SENSE) {
xs 775 dev/isa/wds.c bcopy(&scb->sense_data, &xs->sense, sizeof (struct scsi_sense_data));
xs 777 dev/isa/wds.c if (xs->error == XS_NOERROR) {
xs 781 dev/isa/wds.c xs->resid = 0;
xs 790 dev/isa/wds.c xs->error = XS_DRIVER_STUFFUP; /* Experiment */
xs 799 dev/isa/wds.c xs->error = XS_BUSY;
xs 806 dev/isa/wds.c xs->resid = 0;
xs 810 dev/isa/wds.c xs->error = XS_DRIVER_STUFFUP; /* Experiment */
xs 821 dev/isa/wds.c xs->error = XS_SELTIMEOUT;
xs 830 dev/isa/wds.c xs->error = XS_DRIVER_STUFFUP;
xs 836 dev/isa/wds.c if (NEEDBUFFER(sc) && xs->datalen) {
xs 837 dev/isa/wds.c if (xs->flags & SCSI_DATA_IN)
xs 838 dev/isa/wds.c bcopy(scb->buf->data, xs->data, xs->datalen);
xs 844 dev/isa/wds.c if (xs->flags & SCSI_DATA_IN)
xs 845 dev/isa/wds.c isadma_copyfrombuf(xs->data, xs->datalen,
xs 847 dev/isa/wds.c isadma_unmap(xs->data, xs->datalen,
xs 852 dev/isa/wds.c xs->flags |= ITSDONE;
xs 853 dev/isa/wds.c scsi_done(xs);
xs 1001 dev/isa/wds.c scb->xs = NULL;
xs 1047 dev/isa/wds.c wds_scsi_cmd(xs)
xs 1048 dev/isa/wds.c struct scsi_xfer *xs;
xs 1050 dev/isa/wds.c struct scsi_link *sc_link = xs->sc_link;
xs 1067 dev/isa/wds.c if (xs->flags & SCSI_RESET) {
xs 1074 dev/isa/wds.c flags = xs->flags;
xs 1084 dev/isa/wds.c scb->xs = xs;
xs 1085 dev/isa/wds.c scb->timeout = xs->timeout;
xs 1087 dev/isa/wds.c if (xs->flags & SCSI_DATA_UIO) {
xs 1097 dev/isa/wds.c bcopy(xs->cmd, &scb->cmd.scb, xs->cmdlen < 12 ? xs->cmdlen : 12);
xs 1100 dev/isa/wds.c scb->cmd.targ = (xs->sc_link->target << 5) | xs->sc_link->lun;
xs 1105 dev/isa/wds.c scb->cmd.write = (xs->flags & SCSI_DATA_IN) ? 0x80 : 0x00;
xs 1107 dev/isa/wds.c if (!NEEDBUFFER(sc) && xs->datalen) {
xs 1112 dev/isa/wds.c iovp = ((struct uio *)xs->data)->uio_iov;
xs 1113 dev/isa/wds.c datalen = ((struct uio *)xs->data)->uio_iovcnt;
xs 1114 dev/isa/wds.c xs->datalen = 0;
xs 1118 dev/isa/wds.c xs->datalen += iovp->iov_len;
xs 1133 dev/isa/wds.c ("%d @0x%x:- ", xs->datalen, xs->data));
xs 1136 dev/isa/wds.c scb->data_nseg = isadma_map(xs->data, xs->datalen,
xs 1145 dev/isa/wds.c datalen = xs->datalen;
xs 1146 dev/isa/wds.c thiskv = (int)xs->data;
xs 1147 dev/isa/wds.c thisphys = KVTOPHYS(xs->data);
xs 1213 dev/isa/wds.c isadma_copytobuf(xs->data, xs->datalen,
xs 1224 dev/isa/wds.c } else if (xs->datalen > 0) {
xs 1226 dev/isa/wds.c if (xs->datalen > BUFLEN) {
xs 1231 dev/isa/wds.c if (xs->flags & SCSI_DATA_OUT)
xs 1232 dev/isa/wds.c bcopy(xs->data, scb->buf->data, xs->datalen);
xs 1234 dev/isa/wds.c bzero(scb->buf->data, xs->datalen);
xs 1237 dev/isa/wds.c ltophys(xs->datalen, scb->cmd.len);
xs 1262 dev/isa/wds.c if (VOLATILE_XS(xs)) {
xs 1263 dev/isa/wds.c while ((scb->xs->flags & ITSDONE) == 0) {
xs 1268 dev/isa/wds.c isadma_copyfrombuf(xs->data, xs->datalen,
xs 1270 dev/isa/wds.c isadma_unmap(xs->data, xs->datalen,
xs 1274 dev/isa/wds.c scsi_done(xs);
xs 1284 dev/isa/wds.c if (wds_poll(sc, xs, scb->timeout)) {
xs 1286 dev/isa/wds.c if (wds_poll(sc, xs, scb->timeout))
xs 1292 dev/isa/wds.c xs->error = XS_DRIVER_STUFFUP;
xs 1305 dev/isa/wds.c struct scsi_xfer *xs = scb->xs;
xs 1312 dev/isa/wds.c xs->error = XS_SENSE;
xs 1316 dev/isa/wds.c if (NEEDBUFFER(sc) && xs->datalen) {
xs 1317 dev/isa/wds.c if (xs->flags & SCSI_DATA_IN)
xs 1318 dev/isa/wds.c bcopy(scb->buf->data, xs->data, xs->datalen);
xs 1324 dev/isa/wds.c ss->byte2 = xs->sc_link->lun << 5;
xs 1351 dev/isa/wds.c wds_poll(sc, xs, count)
xs 1353 dev/isa/wds.c struct scsi_xfer *xs;
xs 1367 dev/isa/wds.c if (xs->flags & ITSDONE)
xs 1408 dev/isa/wds.c struct scsi_xfer *xs;
xs 1417 dev/isa/wds.c xs = scb->xs;
xs 1418 dev/isa/wds.c sc_link = xs->sc_link;
xs 1447 dev/isa/wds.c scb->xs->error = XS_TIMEOUT;
xs 79 dev/isa/wdsreg.h struct scsi_xfer *xs;
xs 651 dev/pci/arc.c arc_scsi_cmd(struct scsi_xfer *xs)
xs 653 dev/pci/arc.c struct scsi_link *link = xs->sc_link;
xs 661 dev/pci/arc.c if (xs->cmdlen > ARC_MSG_CDBLEN) {
xs 662 dev/pci/arc.c bzero(&xs->sense, sizeof(xs->sense));
xs 663 dev/pci/arc.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 664 dev/pci/arc.c xs->sense.flags = SKEY_ILLEGAL_REQUEST;
xs 665 dev/pci/arc.c xs->sense.add_sense_code = 0x20;
xs 666 dev/pci/arc.c xs->error = XS_SENSE;
xs 668 dev/pci/arc.c scsi_done(xs);
xs 677 dev/pci/arc.c xs->error = XS_DRIVER_STUFFUP;
xs 679 dev/pci/arc.c scsi_done(xs);
xs 684 dev/pci/arc.c ccb->ccb_xs = xs;
xs 687 dev/pci/arc.c xs->error = XS_DRIVER_STUFFUP;
xs 690 dev/pci/arc.c scsi_done(xs);
xs 703 dev/pci/arc.c cmd->cdb_len = xs->cmdlen;
xs 705 dev/pci/arc.c if (xs->flags & SCSI_DATA_OUT)
xs 713 dev/pci/arc.c cmd->data_len = htole32(xs->datalen);
xs 715 dev/pci/arc.c bcopy(xs->cmd, cmd->cdb, xs->cmdlen);
xs 724 dev/pci/arc.c if (xs->flags & SCSI_POLL) {
xs 726 dev/pci/arc.c if (arc_complete(sc, ccb, xs->timeout) != 0) {
xs 727 dev/pci/arc.c xs->error = XS_DRIVER_STUFFUP;
xs 728 dev/pci/arc.c scsi_done(xs);
xs 740 dev/pci/arc.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 746 dev/pci/arc.c if (xs->datalen == 0)
xs 750 dev/pci/arc.c xs->data, xs->datalen, NULL,
xs 751 dev/pci/arc.c (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
xs 767 dev/pci/arc.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
xs 776 dev/pci/arc.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 779 dev/pci/arc.c if (xs->datalen != 0) {
xs 781 dev/pci/arc.c ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
xs 787 dev/pci/arc.c xs->flags |= ITSDONE;
xs 796 dev/pci/arc.c xs->status = SCSI_OK;
xs 797 dev/pci/arc.c xs->error = XS_SELTIMEOUT;
xs 801 dev/pci/arc.c bzero(&xs->sense, sizeof(xs->sense));
xs 802 dev/pci/arc.c bcopy(cmd->sense_data, &xs->sense,
xs 803 dev/pci/arc.c min(ARC_MSG_SENSELEN, sizeof(xs->sense)));
xs 804 dev/pci/arc.c xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
xs 805 dev/pci/arc.c xs->status = SCSI_CHECK;
xs 806 dev/pci/arc.c xs->error = XS_SENSE;
xs 807 dev/pci/arc.c xs->resid = 0;
xs 812 dev/pci/arc.c xs->error = XS_BUSY; /* try again later? */
xs 813 dev/pci/arc.c xs->status = SCSI_BUSY;
xs 817 dev/pci/arc.c xs->status = SCSI_OK;
xs 818 dev/pci/arc.c xs->error = XS_NOERROR;
xs 819 dev/pci/arc.c xs->resid = 0;
xs 823 dev/pci/arc.c scsi_done(xs);
xs 495 dev/pci/ips.c ips_scsi_cmd(struct scsi_xfer *xs)
xs 497 dev/pci/ips.c struct scsi_link *link = xs->sc_link;
xs 513 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 515 dev/pci/ips.c scsi_done(xs);
xs 522 dev/pci/ips.c xs->error = XS_NOERROR;
xs 525 dev/pci/ips.c switch (xs->cmd->opcode) {
xs 530 dev/pci/ips.c if (xs->cmdlen == sizeof(struct scsi_rw)) {
xs 531 dev/pci/ips.c rw = (void *)xs->cmd;
xs 536 dev/pci/ips.c rwb = (void *)xs->cmd;
xs 546 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 547 dev/pci/ips.c scsi_done(xs);
xs 551 dev/pci/ips.c if (xs->flags & SCSI_DATA_IN) {
xs 558 dev/pci/ips.c if (xs->flags & SCSI_POLL)
xs 561 dev/pci/ips.c if ((error = ips_cmd(sc, cmd, target, blkno, xs->data,
xs 562 dev/pci/ips.c blkcnt * IPS_SECSZ, flags, xs))) {
xs 570 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 571 dev/pci/ips.c scsi_done(xs);
xs 582 dev/pci/ips.c id = (void *)xs->data;
xs 594 dev/pci/ips.c rcd = (void *)xs->data;
xs 600 dev/pci/ips.c sd = (void *)xs->data;
xs 607 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 615 dev/pci/ips.c sc->sc_dev.dv_xname, xs->cmd->opcode));
xs 616 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 618 dev/pci/ips.c scsi_done(xs);
xs 626 dev/pci/ips.c size_t size, int flags, struct scsi_xfer *xs)
xs 644 dev/pci/ips.c ccb->c_xfer = xs;
xs 741 dev/pci/ips.c struct scsi_xfer *xs = ccb->c_xfer;
xs 748 dev/pci/ips.c if (xs != NULL) {
xs 749 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 750 dev/pci/ips.c scsi_done(xs);
xs 776 dev/pci/ips.c if (xs != NULL) {
xs 778 dev/pci/ips.c xs->error = XS_DRIVER_STUFFUP;
xs 780 dev/pci/ips.c xs->resid = 0;
xs 781 dev/pci/ips.c xs->flags |= ITSDONE;
xs 782 dev/pci/ips.c scsi_done(xs);
xs 1075 dev/pci/isp_pci.c isp_pci_dmasetup(struct ispsoftc *isp, XS_T *xs, ispreq_t *rq,
xs 1086 dev/pci/isp_pci.c if (xs->datalen == 0) {
xs 1091 dev/pci/isp_pci.c if (xs->flags & SCSI_DATA_IN) {
xs 1099 dev/pci/isp_pci.c ((ispreqt2_t *)rq)->req_totalcnt = xs->datalen;
xs 1103 dev/pci/isp_pci.c if (XS_CDBLEN(xs) > 12)
xs 1108 dev/pci/isp_pci.c error = bus_dmamap_load(isp->isp_dmatag, dmap, xs->data, xs->datalen,
xs 1109 dev/pci/isp_pci.c NULL, (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
xs 1111 dev/pci/isp_pci.c XS_SETERR(xs, HBA_BOTCH);
xs 1118 dev/pci/isp_pci.c xs->datalen, (xs->flags & SCSI_DATA_IN)? "read to" :
xs 1119 dev/pci/isp_pci.c "write from", xs->data, segcnt);
xs 1157 dev/pci/isp_pci.c XS_SETERR(xs, HBA_BOTCH);
xs 1182 dev/pci/isp_pci.c (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
xs 1221 dev/pci/isp_pci.c isp_pci_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
xs 1226 dev/pci/isp_pci.c (xs->flags & SCSI_DATA_IN)?
xs 543 dev/pci/pcscp.c ((sc->sc_nexus->xs->flags & SCSI_NOSLEEP) ?
xs 545 dev/pci/pcscp.c ((sc->sc_nexus->xs->flags & SCSI_DATA_IN) ?
xs 515 dev/sbus/isp_sbus.c isp_sbus_dmasetup(struct ispsoftc *isp, XS_T *xs, ispreq_t *rq,
xs 521 dev/sbus/isp_sbus.c int cansleep = (xs->flags & SCSI_NOSLEEP) == 0;
xs 522 dev/sbus/isp_sbus.c int in = (xs->flags & SCSI_DATA_IN) != 0;
xs 525 dev/sbus/isp_sbus.c if (xs->datalen == 0) {
xs 535 dev/sbus/isp_sbus.c if (bus_dmamap_load(isp->isp_dmatag, dmap, xs->data, xs->datalen,
xs 538 dev/sbus/isp_sbus.c XS_SETERR(xs, HBA_BOTCH);
xs 542 dev/sbus/isp_sbus.c bus_dmamap_sync(isp->isp_dmatag, dmap, 0, xs->datalen,
xs 551 dev/sbus/isp_sbus.c if (XS_CDBLEN(xs) > 12) {
xs 561 dev/sbus/isp_sbus.c XS_SETERR(xs, HBA_BOTCH);
xs 568 dev/sbus/isp_sbus.c crq->req_dataseg[0].ds_count = xs->datalen;
xs 574 dev/sbus/isp_sbus.c rq->req_dataseg[0].ds_count = xs->datalen;
xs 579 dev/sbus/isp_sbus.c if (XS_CDBLEN(xs) > 12) {
xs 589 dev/sbus/isp_sbus.c isp_sbus_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
xs 601 dev/sbus/isp_sbus.c xs->datalen, (xs->flags & SCSI_DATA_IN)?
xs 271 dev/sdmmc/sdmmc_scsi.c sdmmc_scsi_decode_rw(struct scsi_xfer *xs, u_int32_t *blocknop,
xs 277 dev/sdmmc/sdmmc_scsi.c if (xs->cmdlen == 6) {
xs 278 dev/sdmmc/sdmmc_scsi.c rw = (struct scsi_rw *)xs->cmd;
xs 282 dev/sdmmc/sdmmc_scsi.c rwb = (struct scsi_rw_big *)xs->cmd;
xs 289 dev/sdmmc/sdmmc_scsi.c sdmmc_scsi_cmd(struct scsi_xfer *xs)
xs 291 dev/sdmmc/sdmmc_scsi.c struct scsi_link *link = xs->sc_link;
xs 307 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 308 dev/sdmmc/sdmmc_scsi.c xs->flags |= ITSDONE;
xs 310 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 316 dev/sdmmc/sdmmc_scsi.c DEVNAME(sc), link->target, xs->cmd->opcode, curproc ?
xs 317 dev/sdmmc/sdmmc_scsi.c curproc->p_comm : "", xs->flags & SCSI_POLL));
xs 319 dev/sdmmc/sdmmc_scsi.c xs->error = XS_NOERROR;
xs 321 dev/sdmmc/sdmmc_scsi.c switch (xs->cmd->opcode) {
xs 339 dev/sdmmc/sdmmc_scsi.c bcopy(&inq, xs->data, MIN(xs->datalen, sizeof inq));
xs 341 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 354 dev/sdmmc/sdmmc_scsi.c bcopy(&rcd, xs->data, MIN(xs->datalen, sizeof rcd));
xs 356 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 362 dev/sdmmc/sdmmc_scsi.c DEVNAME(sc), xs->cmd->opcode));
xs 363 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 365 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 371 dev/sdmmc/sdmmc_scsi.c sdmmc_scsi_decode_rw(xs, &blockno, &blockcnt);
xs 377 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 379 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 384 dev/sdmmc/sdmmc_scsi.c ccb = sdmmc_get_ccb(sc->sc_scsibus, xs->flags);
xs 387 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 389 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 394 dev/sdmmc/sdmmc_scsi.c ccb->ccb_xs = xs;
xs 407 dev/sdmmc/sdmmc_scsi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 410 dev/sdmmc/sdmmc_scsi.c timeout_set(&xs->stimeout, sdmmc_stimeout, ccb);
xs 418 dev/sdmmc/sdmmc_scsi.c if (ISSET(xs->flags, SCSI_POLL)) {
xs 423 dev/sdmmc/sdmmc_scsi.c timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
xs 432 dev/sdmmc/sdmmc_scsi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 433 dev/sdmmc/sdmmc_scsi.c struct scsi_link *link = xs->sc_link;
xs 441 dev/sdmmc/sdmmc_scsi.c " complete\n", DEVNAME(sc), link->target, xs->cmd->opcode,
xs 442 dev/sdmmc/sdmmc_scsi.c curproc ? curproc->p_comm : "", xs->flags & SCSI_POLL));
xs 446 dev/sdmmc/sdmmc_scsi.c if (ISSET(xs->flags, SCSI_DATA_IN))
xs 448 dev/sdmmc/sdmmc_scsi.c xs->data, ccb->ccb_blockcnt * DEV_BSIZE);
xs 451 dev/sdmmc/sdmmc_scsi.c xs->data, ccb->ccb_blockcnt * DEV_BSIZE);
xs 454 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 463 dev/sdmmc/sdmmc_scsi.c struct scsi_xfer *xs = ccb->ccb_xs;
xs 465 dev/sdmmc/sdmmc_scsi.c struct scsi_link *link = xs->sc_link;
xs 469 dev/sdmmc/sdmmc_scsi.c timeout_del(&xs->stimeout);
xs 472 dev/sdmmc/sdmmc_scsi.c " done\n", DEVNAME(sc), link->target, xs->cmd->opcode,
xs 473 dev/sdmmc/sdmmc_scsi.c curproc ? curproc->p_comm : "", xs->error));
xs 475 dev/sdmmc/sdmmc_scsi.c xs->resid = 0;
xs 476 dev/sdmmc/sdmmc_scsi.c xs->flags |= ITSDONE;
xs 479 dev/sdmmc/sdmmc_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 482 dev/sdmmc/sdmmc_scsi.c scsi_done(xs);
xs 223 dev/softraid.c sr_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size)
xs 228 dev/softraid.c xs, size);
xs 230 dev/softraid.c if (xs->datalen) {
xs 231 dev/softraid.c copy_cnt = MIN(size, xs->datalen);
xs 232 dev/softraid.c bcopy(v, xs->data, copy_cnt);
xs 438 dev/softraid.c sr_scsi_cmd(struct scsi_xfer *xs)
xs 441 dev/softraid.c struct scsi_link *link = xs->sc_link;
xs 447 dev/softraid.c "flags: %#x\n", DEVNAME(sc), link->scsibus, xs, xs->flags);
xs 470 dev/softraid.c xs->error = XS_NOERROR;
xs 471 dev/softraid.c wu->swu_xs = xs;
xs 473 dev/softraid.c switch (xs->cmd->opcode) {
xs 479 dev/softraid.c DEVNAME(sc), xs->cmd->opcode);
xs 528 dev/softraid.c DEVNAME(sc), xs->cmd->opcode);
xs 536 dev/softraid.c xs->error = XS_SENSE;
xs 537 dev/softraid.c bcopy(&sd->sd_scsi_sense, &xs->sense, sizeof(xs->sense));
xs 540 dev/softraid.c xs->error = XS_DRIVER_STUFFUP;
xs 541 dev/softraid.c xs->flags |= ITSDONE;
xs 545 dev/softraid.c scsi_done(xs);
xs 1378 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 1395 dev/softraid.c sr_copy_internal_data(xs, &inq, sizeof(inq));
xs 1404 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 1412 dev/softraid.c sr_copy_internal_data(xs, &rcd, sizeof(rcd));
xs 1447 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 1453 dev/softraid.c bcopy(&sd->sd_scsi_sense, &xs->sense, sizeof(xs->sense));
xs 1465 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 1466 dev/softraid.c struct scsi_start_stop *ss = (struct scsi_start_stop *)xs->cmd;
xs 2573 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 2581 dev/softraid.c xs->cmd->opcode);
xs 2589 dev/softraid.c if (xs->datalen == 0) {
xs 2595 dev/softraid.c if (xs->cmdlen == 10)
xs 2596 dev/softraid.c blk = _4btol(((struct scsi_rw_big *)xs->cmd)->addr);
xs 2597 dev/softraid.c else if (xs->cmdlen == 6)
xs 2598 dev/softraid.c blk = _3btol(((struct scsi_rw *)xs->cmd)->addr);
xs 2606 dev/softraid.c wu->swu_blk_end = blk + (xs->datalen >> 9) - 1;
xs 2611 dev/softraid.c wu->swu_blk_end, xs->datalen);
xs 2625 dev/softraid.c if (xs->flags & SCSI_DATA_IN)
xs 2641 dev/softraid.c if (xs->flags & SCSI_POLL) {
xs 2650 dev/softraid.c ccb->ccb_buf.b_bcount = xs->datalen;
xs 2651 dev/softraid.c ccb->ccb_buf.b_bufsize = xs->datalen;
xs 2652 dev/softraid.c ccb->ccb_buf.b_resid = xs->datalen;
xs 2653 dev/softraid.c ccb->ccb_buf.b_data = xs->data;
xs 2658 dev/softraid.c if (xs->flags & SCSI_DATA_IN) {
xs 2768 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 2773 dev/softraid.c DEVNAME(sc), bp, xs);
xs 2805 dev/softraid.c if (xs->flags & SCSI_DATA_IN) {
xs 2819 dev/softraid.c xs->error = XS_DRIVER_STUFFUP;
xs 2824 dev/softraid.c xs->error = XS_NOERROR;
xs 2825 dev/softraid.c xs->resid = 0;
xs 2826 dev/softraid.c xs->flags |= ITSDONE;
xs 2857 dev/softraid.c scsi_done(xs);
xs 2867 dev/softraid.c xs->error = XS_DRIVER_STUFFUP;
xs 2868 dev/softraid.c xs->flags |= ITSDONE;
xs 2870 dev/softraid.c scsi_done(xs);
xs 2905 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 2920 dev/softraid.c uio->uio_iov->iov_base = xs->data;
xs 2921 dev/softraid.c uio->uio_iov->iov_len = xs->datalen;
xs 2923 dev/softraid.c if (xs->cmdlen == 10)
xs 2924 dev/softraid.c blk = _4btol(((struct scsi_rw_big *)xs->cmd)->addr);
xs 2925 dev/softraid.c else if (xs->cmdlen == 6)
xs 2926 dev/softraid.c blk = _3btol(((struct scsi_rw *)xs->cmd)->addr);
xs 2928 dev/softraid.c n = xs->datalen >> 9;
xs 2935 dev/softraid.c crp->crp_ilen = xs->datalen;
xs 3039 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 3047 dev/softraid.c xs->cmd->opcode);
xs 3055 dev/softraid.c if (xs->datalen == 0) {
xs 3061 dev/softraid.c if (xs->cmdlen == 10)
xs 3062 dev/softraid.c blk = _4btol(((struct scsi_rw_big *)xs->cmd)->addr);
xs 3063 dev/softraid.c else if (xs->cmdlen == 6)
xs 3064 dev/softraid.c blk = _3btol(((struct scsi_rw *)xs->cmd)->addr);
xs 3072 dev/softraid.c wu->swu_blk_end = blk + (xs->datalen >> 9) - 1;
xs 3077 dev/softraid.c wu->swu_blk_end, xs->datalen);
xs 3102 dev/softraid.c if (xs->flags & SCSI_POLL) {
xs 3112 dev/softraid.c ccb->ccb_buf.b_bcount = xs->datalen;
xs 3113 dev/softraid.c ccb->ccb_buf.b_bufsize = xs->datalen;
xs 3114 dev/softraid.c ccb->ccb_buf.b_resid = xs->datalen;
xs 3115 dev/softraid.c ccb->ccb_buf.b_data = xs->data;
xs 3120 dev/softraid.c if (xs->flags & SCSI_DATA_IN) {
xs 3241 dev/softraid.c struct scsi_xfer *xs = wu->swu_xs;
xs 3246 dev/softraid.c DEVNAME(sc), crp, xs);
xs 3271 dev/softraid.c xs->error = XS_DRIVER_STUFFUP;
xs 3273 dev/softraid.c xs->error = XS_NOERROR;
xs 3275 dev/softraid.c xs->resid = 0;
xs 3276 dev/softraid.c xs->flags |= ITSDONE;
xs 3303 dev/softraid.c scsi_done(xs);
xs 257 dev/tc/asc_tc.c sc->sc_nexus->xs->sc_link->target;
xs 179 dev/usb/umass_scsi.c umass_scsi_cmd(struct scsi_xfer *xs)
xs 181 dev/usb/umass_scsi.c struct scsi_link *sc_link = xs->sc_link;
xs 196 dev/usb/umass_scsi.c sc_link->target, sc_link->lun, xs, xs->cmd->opcode,
xs 197 dev/usb/umass_scsi.c xs->datalen, sc_link->quirks, xs->flags & SCSI_POLL));
xs 201 dev/usb/umass_scsi.c show_scsi_xs(xs);
xs 203 dev/usb/umass_scsi.c show_scsi_cmd(xs);
xs 207 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 215 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 220 dev/usb/umass_scsi.c cmd = xs->cmd;
xs 221 dev/usb/umass_scsi.c cmdlen = xs->cmdlen;
xs 224 dev/usb/umass_scsi.c if (xs->datalen) {
xs 225 dev/usb/umass_scsi.c switch (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
xs 235 dev/usb/umass_scsi.c if (xs->datalen > UMASS_MAX_TRANSFER_SIZE) {
xs 236 dev/usb/umass_scsi.c printf("umass_cmd: large datalen, %d\n", xs->datalen);
xs 237 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 241 dev/usb/umass_scsi.c if (xs->flags & SCSI_POLL) {
xs 247 dev/usb/umass_scsi.c xs->data, xs->datalen, dir,
xs 248 dev/usb/umass_scsi.c xs->timeout, umass_scsi_cb, xs);
xs 252 dev/usb/umass_scsi.c if (xs->error == XS_NOERROR) {
xs 255 dev/usb/umass_scsi.c xs->error = XS_NOERROR;
xs 258 dev/usb/umass_scsi.c xs->error = XS_TIMEOUT;
xs 261 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 267 dev/usb/umass_scsi.c xs->error));
xs 272 dev/usb/umass_scsi.c dir, cmdlen, xs->datalen));
xs 274 dev/usb/umass_scsi.c xs->data, xs->datalen, dir,
xs 275 dev/usb/umass_scsi.c xs->timeout, umass_scsi_cb, xs);
xs 281 dev/usb/umass_scsi.c xs->flags |= ITSDONE;
xs 284 dev/usb/umass_scsi.c scsi_done(xs);
xs 286 dev/usb/umass_scsi.c if (xs->flags & SCSI_POLL)
xs 305 dev/usb/umass_scsi.c struct scsi_xfer *xs = priv;
xs 306 dev/usb/umass_scsi.c struct scsi_link *link = xs->sc_link;
xs 319 dev/usb/umass_scsi.c " status=%d\n", tv.tv_sec, tv.tv_usec, delta, xs, residue,
xs 322 dev/usb/umass_scsi.c xs->resid = residue;
xs 326 dev/usb/umass_scsi.c xs->error = XS_NOERROR;
xs 332 dev/usb/umass_scsi.c if (xs->sc_link->quirks & ADEV_NOSENSE) {
xs 338 dev/usb/umass_scsi.c xs->error = XS_NOERROR;
xs 347 dev/usb/umass_scsi.c if (xs->cmd->opcode == INQUIRY &&
xs 348 dev/usb/umass_scsi.c residue < xs->datalen) {
xs 349 dev/usb/umass_scsi.c xs->error = XS_NOERROR;
xs 353 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 359 dev/usb/umass_scsi.c "scsi op 0x%02x\n", xs->cmd->opcode));
xs 365 dev/usb/umass_scsi.c scbus->sc_sense_cmd.length = sizeof(xs->sense);
xs 370 dev/usb/umass_scsi.c &xs->sense, sizeof(xs->sense),
xs 371 dev/usb/umass_scsi.c DIR_IN, xs->timeout,
xs 372 dev/usb/umass_scsi.c umass_scsi_sense_cb, xs);
xs 376 dev/usb/umass_scsi.c xs->error = XS_RESET;
xs 384 dev/usb/umass_scsi.c if (xs->flags & SCSI_POLL)
xs 387 dev/usb/umass_scsi.c xs->flags |= ITSDONE;
xs 392 dev/usb/umass_scsi.c xs->error, xs->status, xs->resid));
xs 395 dev/usb/umass_scsi.c scsi_done(xs);
xs 406 dev/usb/umass_scsi.c struct scsi_xfer *xs = priv;
xs 410 dev/usb/umass_scsi.c "status=%d\n", xs, residue, status));
xs 418 dev/usb/umass_scsi.c xs->error = XS_SENSE;
xs 420 dev/usb/umass_scsi.c xs->error = XS_SHORTSENSE;
xs 425 dev/usb/umass_scsi.c xs->error = XS_DRIVER_STUFFUP;
xs 429 dev/usb/umass_scsi.c xs->flags |= ITSDONE;
xs 432 dev/usb/umass_scsi.c "xs->flags=0x%x xs->resid=%d\n", xs->error, xs->status,
xs 433 dev/usb/umass_scsi.c xs->resid));
xs 436 dev/usb/umass_scsi.c scsi_done(xs);
xs 162 dev/usb/usscanner.c int usscanner_scsipi_cmd(struct scsipi_xfer *xs);
xs 459 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 460 dev/usb/usscanner.c struct scsipi_link *sc_link = xs->sc_link;
xs 468 dev/usb/usscanner.c sense_cmd.length = sizeof xs->sense;
xs 479 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 515 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 528 dev/usb/usscanner.c xs->resid = xs->datalen - len;
xs 532 dev/usb/usscanner.c if (xs->xs_control & XS_CTL_DATA_IN)
xs 533 dev/usb/usscanner.c memcpy(xs->data, sc->sc_data_buffer, len);
xs 534 dev/usb/usscanner.c xs->error = XS_NOERROR;
xs 537 dev/usb/usscanner.c xs->error = XS_TIMEOUT;
xs 540 dev/usb/usscanner.c if (xs->error == XS_SENSE) {
xs 546 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
xs 557 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 572 dev/usb/usscanner.c memcpy(&xs->sense, sc->sc_data_buffer, len);
xs 573 dev/usb/usscanner.c if (len < sizeof xs->sense)
xs 574 dev/usb/usscanner.c xs->error = XS_SHORTSENSE;
xs 577 dev/usb/usscanner.c xs->error = XS_TIMEOUT;
xs 580 dev/usb/usscanner.c xs->error = XS_RESET;
xs 583 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
xs 592 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 604 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 612 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 620 dev/usb/usscanner.c xs->sc_link->flags |= DEBUGLEVEL;
xs 625 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 634 dev/usb/usscanner.c xs->error = XS_TIMEOUT;
xs 637 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
xs 644 dev/usb/usscanner.c sizeof xs->sense, USBD_SHORT_XFER_OK | USBD_NO_COPY,
xs 649 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 659 dev/usb/usscanner.c struct scsipi_xfer *xs = sc->sc_xs;
xs 668 dev/usb/usscanner.c xs->sc_link->flags |= DEBUGLEVEL;
xs 673 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 682 dev/usb/usscanner.c xs->error = XS_TIMEOUT;
xs 687 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP; /* XXX ? */
xs 691 dev/usb/usscanner.c if (xs->datalen == 0) {
xs 693 dev/usb/usscanner.c xs->error = XS_NOERROR;
xs 697 dev/usb/usscanner.c if (xs->xs_control & XS_CTL_DATA_IN) {
xs 699 dev/usb/usscanner.c xs->datalen));
xs 703 dev/usb/usscanner.c xs->datalen));
xs 704 dev/usb/usscanner.c memcpy(sc->sc_data_buffer, xs->data, xs->datalen);
xs 709 dev/usb/usscanner.c xs->datalen, USBD_SHORT_XFER_OK | USBD_NO_COPY,
xs 710 dev/usb/usscanner.c xs->timeout, usscanner_data_cb);
xs 714 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 721 dev/usb/usscanner.c usscanner_scsipi_cmd(struct scsipi_xfer *xs)
xs 723 dev/usb/usscanner.c struct scsipi_link *sc_link = xs->sc_link;
xs 732 dev/usb/usscanner.c xs, xs->cmd->opcode, xs->datalen,
xs 733 dev/usb/usscanner.c sc_link->quirks, xs->xs_control & XS_CTL_POLL));
xs 737 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 746 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 752 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 757 dev/usb/usscanner.c if (xs->datalen > USSCANNER_MAX_TRANSFER_SIZE) {
xs 758 dev/usb/usscanner.c printf("umass_cmd: large datalen, %d\n", xs->datalen);
xs 759 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 764 dev/usb/usscanner.c xs->cmdlen, xs->datalen));
xs 766 dev/usb/usscanner.c sc->sc_xs = xs;
xs 767 dev/usb/usscanner.c memcpy(sc->sc_cmd_buffer, xs->cmd, xs->cmdlen);
xs 769 dev/usb/usscanner.c xs->cmdlen, USBD_NO_COPY, USSCANNER_TIMEOUT, usscanner_cmd_cb);
xs 772 dev/usb/usscanner.c xs->error = XS_DRIVER_STUFFUP;
xs 781 dev/usb/usscanner.c xs->xs_status |= XS_STS_DONE;
xs 782 dev/usb/usscanner.c scsipi_done(xs);
xs 783 dev/usb/usscanner.c if (xs->xs_control & XS_CTL_POLL)
xs 474 nfs/krpc_subr.c struct xdr_string *xs;
xs 492 nfs/krpc_subr.c xs = mtod(m, struct xdr_string *);
xs 494 nfs/krpc_subr.c xs->len = txdr_unsigned(len);
xs 495 nfs/krpc_subr.c bcopy(str, xs->data, len);
xs 505 nfs/krpc_subr.c struct xdr_string *xs;
xs 514 nfs/krpc_subr.c xs = mtod(m, struct xdr_string *);
xs 515 nfs/krpc_subr.c slen = fxdr_unsigned(u_int32_t, xs->len);
xs 679 scsi/cd.c cddone(struct scsi_xfer *xs)
xs 681 scsi/cd.c struct cd_softc *cd = xs->sc_link->device_softc;
xs 683 scsi/cd.c if (xs->bp != NULL)
xs 684 scsi/cd.c disk_unbusy(&cd->sc_dk, xs->bp->b_bcount - xs->bp->b_resid,
xs 685 scsi/cd.c (xs->bp->b_flags & B_READ));
xs 1987 scsi/cd.c cd_interpret_sense(struct scsi_xfer *xs)
xs 1989 scsi/cd.c struct scsi_sense_data *sense = &xs->sense;
xs 1990 scsi/cd.c struct scsi_link *sc_link = xs->sc_link;
xs 2012 scsi/cd.c if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
xs 2018 scsi/cd.c xs->retries++;
xs 2019 scsi/cd.c return (scsi_delay(xs, 1));
xs 120 scsi/ch.c int ch_interpret_sense(struct scsi_xfer *xs);
xs 763 scsi/ch.c ch_interpret_sense(xs)
xs 764 scsi/ch.c struct scsi_xfer *xs;
xs 766 scsi/ch.c struct scsi_sense_data *sense = &xs->sense;
xs 767 scsi/ch.c struct scsi_link *sc_link = xs->sc_link;
xs 790 scsi/ch.c if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
xs 797 scsi/ch.c xs->retries++;
xs 798 scsi/ch.c return (scsi_delay(xs, 1));
xs 111 scsi/scsi_base.c struct scsi_xfer *xs;
xs 132 scsi/scsi_base.c xs = pool_get(&scsi_xfer_pool,
xs 134 scsi/scsi_base.c if (xs != NULL) {
xs 135 scsi/scsi_base.c bzero(xs, sizeof(*xs));
xs 137 scsi/scsi_base.c xs->flags = flags;
xs 146 scsi/scsi_base.c return (xs);
xs 155 scsi/scsi_base.c scsi_free_xs(struct scsi_xfer *xs, int start)
xs 157 scsi/scsi_base.c struct scsi_link *sc_link = xs->sc_link;
xs 163 scsi/scsi_base.c pool_put(&scsi_xfer_pool, xs);
xs 185 scsi/scsi_base.c struct scsi_xfer *xs;
xs 187 scsi/scsi_base.c if ((xs = scsi_get_xs(sc_link, flags)) == NULL)
xs 194 scsi/scsi_base.c xs->sc_link = sc_link;
xs 195 scsi/scsi_base.c bcopy(scsi_cmd, &xs->cmdstore, cmdlen);
xs 196 scsi/scsi_base.c xs->cmd = &xs->cmdstore;
xs 197 scsi/scsi_base.c xs->cmdlen = cmdlen;
xs 198 scsi/scsi_base.c xs->data = data_addr;
xs 199 scsi/scsi_base.c xs->datalen = datalen;
xs 200 scsi/scsi_base.c xs->retries = retries;
xs 201 scsi/scsi_base.c xs->timeout = timeout;
xs 202 scsi/scsi_base.c xs->bp = bp;
xs 213 scsi/scsi_base.c xs->cmd->bytes[0] &= ~SCSI_CMD_LUN_MASK;
xs 215 scsi/scsi_base.c xs->cmd->bytes[0] |= ((sc_link->lun << SCSI_CMD_LUN_SHIFT) &
xs 218 scsi/scsi_base.c return (xs);
xs 682 scsi/scsi_base.c scsi_done(struct scsi_xfer *xs)
xs 684 scsi/scsi_base.c struct scsi_link *sc_link = xs->sc_link;
xs 693 scsi/scsi_base.c show_scsi_cmd(xs);
xs 701 scsi/scsi_base.c if ((xs->flags & SCSI_USER) != 0) {
xs 703 scsi/scsi_base.c scsi_user_done(xs); /* to take a copy of the sense etc. */
xs 706 scsi/scsi_base.c scsi_free_xs(xs, 1); /* restarts queue too */
xs 711 scsi/scsi_base.c if (!((xs->flags & (SCSI_NOSLEEP | SCSI_POLL)) == SCSI_NOSLEEP)) {
xs 717 scsi/scsi_base.c wakeup(xs);
xs 726 scsi/scsi_base.c error = sc_err1(xs);
xs 728 scsi/scsi_base.c switch ((*(sc_link->adapter->scsi_cmd)) (xs)) {
xs 733 scsi/scsi_base.c xs->error = XS_BUSY;
xs 740 scsi/scsi_base.c bp = xs->bp;
xs 748 scsi/scsi_base.c bp->b_resid = xs->resid;
xs 759 scsi/scsi_base.c (*sc_link->device->done)(xs);
xs 761 scsi/scsi_base.c scsi_free_xs(xs, 1);
xs 767 scsi/scsi_base.c scsi_execute_xs(struct scsi_xfer *xs)
xs 771 scsi/scsi_base.c xs->flags &= ~ITSDONE;
xs 772 scsi/scsi_base.c xs->error = XS_NOERROR;
xs 773 scsi/scsi_base.c xs->resid = xs->datalen;
xs 774 scsi/scsi_base.c xs->status = 0;
xs 806 scsi/scsi_base.c flags = xs->flags;
xs 814 scsi/scsi_base.c rslt = (*(xs->sc_link->adapter->scsi_cmd))(xs);
xs 825 scsi/scsi_base.c while ((xs->flags & ITSDONE) == 0)
xs 826 scsi/scsi_base.c tsleep(xs, PRIBIO + 1, "scsicmd", 0);
xs 832 scsi/scsi_base.c if (xs->bp)
xs 835 scsi/scsi_base.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("back in cmd()\n"));
xs 836 scsi/scsi_base.c if ((error = sc_err1(xs)) != ERESTART)
xs 841 scsi/scsi_base.c xs->error = XS_BUSY;
xs 868 scsi/scsi_base.c struct scsi_xfer *xs;
xs 879 scsi/scsi_base.c if ((xs = scsi_make_xs(sc_link, scsi_cmd, cmdlen, data_addr, datalen,
xs 883 scsi/scsi_base.c if ((error = scsi_execute_xs(xs)) == EJUSTRETURN)
xs 889 scsi/scsi_base.c scsi_free_xs(xs, 0); /* Don't restart queue. */
xs 891 scsi/scsi_base.c scsi_free_xs(xs, 1);
xs 899 scsi/scsi_base.c sc_err1(struct scsi_xfer *xs)
xs 903 scsi/scsi_base.c SC_DEBUG(xs->sc_link, SDEV_DB3, ("sc_err1,err = 0x%x\n", xs->error));
xs 912 scsi/scsi_base.c switch (xs->error) {
xs 919 scsi/scsi_base.c if ((error = scsi_interpret_sense(xs)) == ERESTART)
xs 921 scsi/scsi_base.c SC_DEBUG(xs->sc_link, SDEV_DB3,
xs 926 scsi/scsi_base.c if (xs->retries) {
xs 927 scsi/scsi_base.c if ((error = scsi_delay(xs, 1)) == EIO)
xs 933 scsi/scsi_base.c if (xs->retries--) {
xs 934 scsi/scsi_base.c xs->error = XS_NOERROR;
xs 935 scsi/scsi_base.c xs->flags &= ~ITSDONE;
xs 950 scsi/scsi_base.c if (xs->retries) {
xs 951 scsi/scsi_base.c SC_DEBUG(xs->sc_link, SDEV_DB3,
xs 959 scsi/scsi_base.c sc_print_addr(xs->sc_link);
xs 961 scsi/scsi_base.c xs->error);
xs 970 scsi/scsi_base.c scsi_delay(struct scsi_xfer *xs, int seconds)
xs 972 scsi/scsi_base.c switch (xs->flags & (SCSI_POLL | SCSI_NOSLEEP)) {
xs 1001 scsi/scsi_base.c scsi_interpret_sense(struct scsi_xfer *xs)
xs 1003 scsi/scsi_base.c struct scsi_sense_data *sense = &xs->sense;
xs 1004 scsi/scsi_base.c struct scsi_link *sc_link = xs->sc_link;
xs 1019 scsi/scsi_base.c show_mem((u_char *)&xs->sense, sizeof xs->sense);
xs 1030 scsi/scsi_base.c error = (*sc_link->device->err_handler) (xs);
xs 1049 scsi/scsi_base.c if (xs->resid == xs->datalen)
xs 1050 scsi/scsi_base.c xs->resid = 0; /* not short read */
xs 1056 scsi/scsi_base.c if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
xs 1059 scsi/scsi_base.c if (xs->retries) {
xs 1071 scsi/scsi_base.c return (scsi_delay(xs, 1));
xs 1110 scsi/scsi_base.c if ((xs->flags & SCSI_IGNORE_ILLEGAL_REQUEST) != 0)
xs 1126 scsi/scsi_base.c return (scsi_delay(xs, 1));
xs 1132 scsi/scsi_base.c if ((xs->flags & SCSI_IGNORE_MEDIA_CHANGE) != 0 ||
xs 1135 scsi/scsi_base.c return (scsi_delay(xs, 1));
xs 1158 scsi/scsi_base.c if (skey && (xs->flags & SCSI_SILENT) == 0)
xs 1159 scsi/scsi_base.c scsi_print_sense(xs);
xs 1784 scsi/scsi_base.c scsi_print_sense(struct scsi_xfer *xs)
xs 1786 scsi/scsi_base.c struct scsi_sense_data *sense = &xs->sense;
xs 1792 scsi/scsi_base.c sc_print_addr(xs->sc_link);
xs 1797 scsi/scsi_base.c xs->cmd->opcode);
xs 1916 scsi/scsi_base.c show_scsi_xs(struct scsi_xfer *xs)
xs 1918 scsi/scsi_base.c printf("xs(%p): ", xs);
xs 1919 scsi/scsi_base.c printf("flg(0x%x)", xs->flags);
xs 1920 scsi/scsi_base.c printf("sc_link(%p)", xs->sc_link);
xs 1921 scsi/scsi_base.c printf("retr(0x%x)", xs->retries);
xs 1922 scsi/scsi_base.c printf("timo(0x%x)", xs->timeout);
xs 1923 scsi/scsi_base.c printf("cmd(%p)", xs->cmd);
xs 1924 scsi/scsi_base.c printf("len(0x%x)", xs->cmdlen);
xs 1925 scsi/scsi_base.c printf("data(%p)", xs->data);
xs 1926 scsi/scsi_base.c printf("len(0x%x)", xs->datalen);
xs 1927 scsi/scsi_base.c printf("res(0x%x)", xs->resid);
xs 1928 scsi/scsi_base.c printf("err(0x%x)", xs->error);
xs 1929 scsi/scsi_base.c printf("bp(%p)", xs->bp);
xs 1930 scsi/scsi_base.c show_scsi_cmd(xs);
xs 1934 scsi/scsi_base.c show_scsi_cmd(struct scsi_xfer *xs)
xs 1936 scsi/scsi_base.c u_char *b = (u_char *) xs->cmd;
xs 1939 scsi/scsi_base.c sc_print_addr(xs->sc_link);
xs 1942 scsi/scsi_base.c if ((xs->flags & SCSI_RESET) == 0) {
xs 1943 scsi/scsi_base.c while (i < xs->cmdlen) {
xs 1948 scsi/scsi_base.c printf("-[%d bytes]\n", xs->datalen);
xs 1949 scsi/scsi_base.c if (xs->datalen)
xs 1950 scsi/scsi_base.c show_mem(xs->data, min(64, xs->datalen));
xs 162 scsi/scsi_ioctl.c scsi_user_done(struct scsi_xfer *xs)
xs 171 scsi/scsi_ioctl.c bp = xs->bp;
xs 173 scsi/scsi_ioctl.c sc_print_addr(xs->sc_link);
xs 180 scsi/scsi_ioctl.c sc_print_addr(xs->sc_link);
xs 187 scsi/scsi_ioctl.c SC_DEBUG(xs->sc_link, SDEV_DB2, ("user-done\n"));
xs 190 scsi/scsi_ioctl.c screq->status = xs->status;
xs 191 scsi/scsi_ioctl.c switch (xs->error) {
xs 195 scsi/scsi_ioctl.c screq->datalen_used = xs->datalen - xs->resid;
xs 200 scsi/scsi_ioctl.c screq->senselen_used = min(sizeof(xs->sense), SENSEBUFLEN);
xs 201 scsi/scsi_ioctl.c bcopy(&xs->sense, screq->sense, screq->senselen);
xs 206 scsi/scsi_ioctl.c screq->senselen_used = min(sizeof(xs->sense), SENSEBUFLEN);
xs 207 scsi/scsi_ioctl.c bcopy(&xs->sense, screq->sense, screq->senselen);
xs 226 scsi/scsi_ioctl.c xs->error);
xs 757 scsi/sd.c sddone(struct scsi_xfer *xs)
xs 759 scsi/sd.c struct sd_softc *sd = xs->sc_link->device_softc;
xs 766 scsi/sd.c if (xs->bp != NULL)
xs 767 scsi/sd.c disk_unbusy(&sd->sc_dk, (xs->bp->b_bcount - xs->bp->b_resid),
xs 768 scsi/sd.c (xs->bp->b_flags & B_READ));
xs 1090 scsi/sd.c sd_interpret_sense(struct scsi_xfer *xs)
xs 1092 scsi/sd.c struct scsi_sense_data *sense = &xs->sense;
xs 1093 scsi/sd.c struct scsi_link *sc_link = xs->sc_link;
xs 1111 scsi/sd.c retval = scsi_delay(xs, 5);
xs 1186 scsi/sd.c struct scsi_xfer *xs; /* ... convenience */
xs 1232 scsi/sd.c xs = &sx;
xs 1250 scsi/sd.c bzero(xs, sizeof(sx));
xs 1251 scsi/sd.c xs->flags |= SCSI_AUTOCONF | SCSI_DATA_OUT;
xs 1252 scsi/sd.c xs->sc_link = sd->sc_link;
xs 1253 scsi/sd.c xs->retries = SDRETRIES;
xs 1254 scsi/sd.c xs->timeout = 10000; /* 10000 millisecs for a disk ! */
xs 1255 scsi/sd.c xs->cmd = (struct scsi_generic *)&cmd;
xs 1256 scsi/sd.c xs->cmdlen = sizeof(cmd);
xs 1257 scsi/sd.c xs->resid = nwrt * sectorsize;
xs 1258 scsi/sd.c xs->error = XS_NOERROR;
xs 1259 scsi/sd.c xs->bp = NULL;
xs 1260 scsi/sd.c xs->data = va;
xs 1261 scsi/sd.c xs->datalen = nwrt * sectorsize;
xs 1266 scsi/sd.c retval = (*(sd->sc_link->adapter->scsi_cmd)) (xs);
xs 1807 scsi/st.c st_interpret_sense(xs)
xs 1808 scsi/st.c struct scsi_xfer *xs;
xs 1810 scsi/st.c struct scsi_sense_data *sense = &xs->sense;
xs 1811 scsi/st.c struct scsi_link *sc_link = xs->sc_link;
xs 1813 scsi/st.c struct buf *bp = xs->bp;
xs 1837 scsi/st.c if ((xs->flags & SCSI_IGNORE_NOT_READY) != 0)
xs 1844 scsi/st.c xs->retries++;
xs 1845 scsi/st.c return (scsi_delay(xs, 1));
xs 1865 scsi/st.c info = xs->datalen; /* bad choice if fixed blocks */
xs 1867 scsi/st.c xs->resid = info * st->blksize;
xs 1871 scsi/st.c bp->b_resid = xs->resid;
xs 1880 scsi/st.c bp->b_resid = xs->resid;
xs 1885 scsi/st.c bp->b_resid = xs->resid;
xs 1887 scsi/st.c (xs->flags & SCSI_SILENT) == 0)
xs 1905 scsi/st.c if (xs->resid >= xs->datalen) {
xs 1910 scsi/st.c bp->b_resid = xs->resid;
xs 1915 scsi/st.c xs->resid = xs->datalen; /* to be sure */
xs 1932 scsi/st.c if ((xs->flags & SCSI_SILENT) == 0)
xs 1935 scsi/st.c xs->datalen - info);
xs 1937 scsi/st.c } else if (info > xs->datalen) {
xs 1941 scsi/st.c if ((xs->flags & SCSI_SILENT) == 0) {
xs 1945 scsi/st.c xs->datalen);
xs 1949 scsi/st.c xs->resid = info;
xs 1968 scsi/st.c xs->resid = xs->datalen;
xs 1970 scsi/st.c bp->b_resid = xs->resid;