root/dev/ata/atascsi.c

DEFINITIONS

1. atascsi_attach
2. atascsi_detach
3. atascsi_probe
4. ata_setup_identify
5. ata_free_identify
6. ata_complete_identify
7. atascsi_cmd
8. atascsi_disk_cmd
9. atascsi_empty_done
10. atascsi_disk_cmd_done
11. atascsi_disk_inq
12. atascsi_disk_inq_done
13. atascsi_disk_sync
14. atascsi_disk_sync_done
15. atascsi_disk_capacity
16. atascsi_disk_capacity_done
17. atascsi_disk_sense
18. atascsi_atapi_cmd
19. atascsi_atapi_cmd_done
20. atascsi_stuffup
21. ata_exec
22. ata_get_xfer
23. ata_put_xfer

    1 /*      $OpenBSD: atascsi.c,v 1.41 2007/04/22 05:11:45 dlg Exp $ */
    3 /*
    4  * Copyright (c) 2007 David Gwynne <dlg@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 #include <sys/param.h>
   20 #include <sys/systm.h>
   21 #include <sys/buf.h>
   22 #include <sys/kernel.h>
   23 #include <sys/malloc.h>
   24 #include <sys/device.h>
   25 #include <sys/proc.h>
   26 #include <sys/queue.h>
   28 #include <scsi/scsi_all.h>
   29 #include <scsi/scsi_disk.h>
   30 #include <scsi/scsiconf.h>
   32 #include <dev/ata/atascsi.h>
   34 struct atascsi {
   35         struct device           *as_dev;
   36         void                    *as_cookie;
   38         struct ata_port         **as_ports;
   40         struct atascsi_methods  *as_methods;
   41         struct scsi_adapter     as_switch;
   42         struct scsi_link        as_link;
   43         struct scsibus_softc    *as_scsibus;
   45         int                     as_capability;
   46 };
   48 int             atascsi_cmd(struct scsi_xfer *);
   50 /* template */
   51 struct scsi_adapter atascsi_switch = {
atascsi_cmd,            /* scsi_cmd */
minphys,                /* scsi_minphys */
NULL,
NULL,
NULL                    /* ioctl */
   57 };
   59 struct scsi_device atascsi_device = {
NULL, NULL, NULL, NULL
   61 };
   63 int             atascsi_probe(struct atascsi *, int);
   65 struct ata_xfer *ata_setup_identify(struct ata_port *, int);
   66 void            ata_free_identify(struct ata_xfer *);
   67 void            ata_complete_identify(struct ata_xfer *,
   68                     struct ata_identify *);
   70 int             atascsi_disk_cmd(struct scsi_xfer *);
   71 void            atascsi_disk_cmd_done(struct ata_xfer *);
   72 int             atascsi_disk_inq(struct scsi_xfer *);
   73 void            atascsi_disk_inq_done(struct ata_xfer *);
   74 int             atascsi_disk_capacity(struct scsi_xfer *);
   75 void            atascsi_disk_capacity_done(struct ata_xfer *);
   76 int             atascsi_disk_sync(struct scsi_xfer *);
   77 void            atascsi_disk_sync_done(struct ata_xfer *);
   78 int             atascsi_disk_sense(struct scsi_xfer *);
   80 void            atascsi_empty_done(struct ata_xfer *);
   82 int             atascsi_atapi_cmd(struct scsi_xfer *);
   83 void            atascsi_atapi_cmd_done(struct ata_xfer *);
   85 int             atascsi_stuffup(struct scsi_xfer *);
   88 int             ata_running = 0;
   90 int             ata_exec(struct atascsi *, struct ata_xfer *);
   92 struct ata_xfer *ata_get_xfer(struct ata_port *, int);
   93 void            ata_put_xfer(struct ata_xfer *);
   95 struct atascsi *
atascsi_attach(struct device *self, struct atascsi_attach_args *aaa)
   97 {
   98         struct scsibus_attach_args      saa;
   99         struct atascsi                  *as;
  100         int                             i;
as = malloc(sizeof(struct atascsi), M_DEVBUF, M_WAITOK);
bzero(as, sizeof(struct atascsi));
as->as_dev = self;
as->as_cookie = aaa->aaa_cookie;
as->as_methods = aaa->aaa_methods;
as->as_capability = aaa->aaa_capability;
  110         /* copy from template and modify for ourselves */
as->as_switch = atascsi_switch;
as->as_switch.scsi_minphys = aaa->aaa_minphys;
  114         /* fill in our scsi_link */
as->as_link.device = &atascsi_device;
as->as_link.adapter = &as->as_switch;
as->as_link.adapter_softc = as;
as->as_link.adapter_buswidth = aaa->aaa_nports;
as->as_link.luns = 1; /* XXX port multiplier as luns */
as->as_link.adapter_target = aaa->aaa_nports;
as->as_link.openings = aaa->aaa_ncmds;
  122         if (as->as_capability & ASAA_CAP_NEEDS_RESERVED)
as->as_link.openings--;
as->as_ports = malloc(sizeof(struct ata_port *) * aaa->aaa_nports,
M_DEVBUF, M_WAITOK);
bzero(as->as_ports, sizeof(struct ata_port *) * aaa->aaa_nports);
  129         /* fill in the port array with the type of devices there */
  130         for (i = 0; i < as->as_link.adapter_buswidth; i++)
atascsi_probe(as, i);
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &as->as_link;
  136         /* stash the scsibus so we can do hotplug on it */
as->as_scsibus = (struct scsibus_softc *)config_found(self, &saa,
scsiprint);
  140         return (as);
  141 }
  143 int
atascsi_detach(struct atascsi *as)
  145 {
  146         return (0);
  147 }
  149 int
atascsi_probe(struct atascsi *as, int port)
  151 {
  152         struct ata_port         *ap;
  153         struct ata_xfer         *xa;
  154         int                     type, s;
  156         if (port > as->as_link.adapter_buswidth)
  157                 return (ENXIO);
type = as->as_methods->probe(as->as_cookie, port);
  160         switch (type) {
  161         case ATA_PORT_T_DISK:
  162                 break;
  163         case ATA_PORT_T_ATAPI:
as->as_link.flags |= SDEV_ATAPI;
as->as_link.quirks |= SDEV_ONLYBIG;
  166                 break;
  167         default:
  168                 return (ENODEV);
  169         }
ap = malloc(sizeof(struct ata_port), M_DEVBUF, M_WAITOK);
bzero(ap, sizeof(struct ata_port));
ap->ap_as = as;
ap->ap_port = port;
ap->ap_type = type;
as->as_ports[port] = ap;
s = splbio();
xa = ata_get_xfer(ap, 1);
splx(s);
  182         if (xa == NULL)
  183                 return (EBUSY);
  185         /*
  186          * FREEZE LOCK the device so malicous users can't lock it on us.
  187          * As there is no harm in issuing this to devices that don't
  188          * support the security feature set we just send it, and don't bother
  189          * checking if the device sends a command abort to tell us it doesn't
  190          * support it
  191          */
xa->fis->command = ATA_C_SEC_FREEZE_LOCK;
xa->fis->flags = ATA_H2D_FLAGS_CMD;
xa->complete = atascsi_empty_done;
xa->flags = ATA_F_POLL | ATA_F_PIO;
xa->timeout = 1000;
ata_exec(as, xa);
  199         return (0);
  200 }
  202 struct ata_xfer *
ata_setup_identify(struct ata_port *ap, int nosleep)
  204 {
  205         struct ata_xfer         *xa;
  206         int                     s;
s = splbio();
xa = ata_get_xfer(ap, nosleep);
splx(s);
  211         if (xa == NULL)
  212                 return (NULL);
xa->data = malloc(512, M_TEMP, nosleep ? M_NOWAIT : M_WAITOK);
  215         if (xa->data == NULL) {
s = splbio();
xa->state = ATA_S_ERROR;
ata_put_xfer(xa);
splx(s);
  220                 return (NULL);
  221         }
bzero(xa->data, 512);
xa->datalen = 512;
xa->fis->flags = ATA_H2D_FLAGS_CMD;
xa->fis->command = ATA_C_IDENTIFY;
xa->fis->device = 0;
xa->flags = ATA_F_READ | ATA_F_PIO;
  231         return (xa);
  232 }
  234 void
ata_free_identify(struct ata_xfer *xa)
  236 {
free(xa->data, M_TEMP);
ata_put_xfer(xa);
  239 }
  241 void
ata_complete_identify(struct ata_xfer *xa, struct ata_identify *id)
  243 {
u_int16_t               *swap;
  245         int                     i;
bcopy(xa->data, id, sizeof(struct ata_identify));
ata_free_identify(xa);
swap = (u_int16_t *)id->serial;
  251         for (i = 0; i < sizeof(id->serial) / sizeof(u_int16_t); i++)
swap[i] = swap16(swap[i]);
swap = (u_int16_t *)id->firmware;
  255         for (i = 0; i < sizeof(id->firmware) / sizeof(u_int16_t); i++)
swap[i] = swap16(swap[i]);
swap = (u_int16_t *)id->model;
  259         for (i = 0; i < sizeof(id->model) / sizeof(u_int16_t); i++)
swap[i] = swap16(swap[i]);
  261 }
  263 int
atascsi_cmd(struct scsi_xfer *xs)
  265 {
  266         struct scsi_link        *link = xs->sc_link;
  267         struct atascsi          *as = link->adapter_softc;
  268         struct ata_port         *ap = as->as_ports[link->target];
  270         if (ap == NULL)
  271                 return (atascsi_stuffup(xs));
  273         switch (ap->ap_type) {
  274         case ATA_PORT_T_DISK:
  275                 return (atascsi_disk_cmd(xs));
  276         case ATA_PORT_T_ATAPI:
  277                 return (atascsi_atapi_cmd(xs));
  279         case ATA_PORT_T_NONE:
  280         default:
  281                 return (atascsi_stuffup(xs));
  282         }
  283 }
  285 int
atascsi_disk_cmd(struct scsi_xfer *xs)
  287 {
  288         struct scsi_link        *link = xs->sc_link;
  289         struct atascsi          *as = link->adapter_softc;
  290         struct ata_port         *ap = as->as_ports[link->target];
  291         int                     s, flags = 0;
  292         struct scsi_rw          *rw;
  293         struct scsi_rw_big      *rwb;
  294         struct ata_xfer         *xa;
  295         struct ata_fis_h2d      *fis;
u_int64_t               lba;
u_int32_t               sector_count;
  299         switch (xs->cmd->opcode) {
  300         case READ_BIG:
  301         case READ_COMMAND:
flags = ATA_F_READ;
  303                 break;
  304         case WRITE_BIG:
  305         case WRITE_COMMAND:
flags = ATA_F_WRITE;
  307                 /* deal with io outside the switch */
  308                 break;
  310         case SYNCHRONIZE_CACHE:
  311                 return (atascsi_disk_sync(xs));
  312         case REQUEST_SENSE:
  313                 return (atascsi_disk_sense(xs));
  314         case INQUIRY:
  315                 return (atascsi_disk_inq(xs));
  316         case READ_CAPACITY:
  317                 return (atascsi_disk_capacity(xs));
  319         case TEST_UNIT_READY:
  320         case START_STOP:
  321         case PREVENT_ALLOW:
  322                 return (COMPLETE);
  324         default:
  325                 return (atascsi_stuffup(xs));
  326         }
s = splbio();
xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
splx(s);
  331         if (xa == NULL)
  332                 return (NO_CCB);
xa->flags = flags;
  335         if (xs->cmdlen == 6) {
rw = (struct scsi_rw *)xs->cmd;
lba = _3btol(rw->addr) & (SRW_TOPADDR << 16 | 0xffff);
sector_count = rw->length ? rw->length : 0x100;
  339         } else {
rwb = (struct scsi_rw_big *)xs->cmd;
lba = _4btol(rwb->addr);
sector_count = _2btol(rwb->length);
  343         }
fis = xa->fis;
fis->flags = ATA_H2D_FLAGS_CMD;
fis->lba_low = lba & 0xff;
fis->lba_mid = (lba >> 8) & 0xff;
fis->lba_high = (lba >> 16) & 0xff;
  352         if (ap->ap_ncqdepth && !(xs->flags & SCSI_POLL)) {
  353                 /* Use NCQ */
xa->flags |= ATA_F_NCQ;
fis->command = (xa->flags & ATA_F_WRITE) ?
ATA_C_WRITE_FPDMA : ATA_C_READ_FPDMA;
fis->device = ATA_H2D_DEVICE_LBA;
fis->lba_low_exp = (lba >> 24) & 0xff;
fis->lba_mid_exp = (lba >> 32) & 0xff;
fis->lba_high_exp = (lba >> 40) & 0xff;
fis->sector_count = xa->tag << 3;
fis->features = sector_count & 0xff;
fis->features_exp = (sector_count >> 8) & 0xff;
  364         } else if (sector_count > 0x100 || lba > 0xfffffff) {
  365                 /* Use LBA48 */
fis->command = (xa->flags & ATA_F_WRITE) ?
ATA_C_WRITEDMA_EXT : ATA_C_READDMA_EXT;
fis->device = ATA_H2D_DEVICE_LBA;
fis->lba_low_exp = (lba >> 24) & 0xff;
fis->lba_mid_exp = (lba >> 32) & 0xff;
fis->lba_high_exp = (lba >> 40) & 0xff;
fis->sector_count = sector_count & 0xff;
fis->sector_count_exp = (sector_count >> 8) & 0xff;
  374         } else {
  375                 /* Use LBA */
fis->command = (xa->flags & ATA_F_WRITE) ?
ATA_C_WRITEDMA : ATA_C_READDMA;
fis->device = ATA_H2D_DEVICE_LBA | ((lba >> 24) & 0x0f);
fis->sector_count = sector_count & 0xff;
  380         }
xa->data = xs->data;
xa->datalen = xs->datalen;
xa->complete = atascsi_disk_cmd_done;
xa->timeout = xs->timeout;
xa->atascsi_private = xs;
  387         if (xs->flags & SCSI_POLL)
xa->flags |= ATA_F_POLL;
  390         return (ata_exec(as, xa));
  391 }
  393 void
atascsi_empty_done(struct ata_xfer *xa)
  395 {
ata_put_xfer(xa);
  397 }
  399 void
atascsi_disk_cmd_done(struct ata_xfer *xa)
  401 {
  402         struct scsi_xfer        *xs = xa->atascsi_private;
  404         switch (xa->state) {
  405         case ATA_S_COMPLETE:
xs->error = XS_NOERROR;
  407                 break;
  408         case ATA_S_ERROR:
  409                 /* fake sense? */
xs->error = XS_DRIVER_STUFFUP;
  411                 break;
  412         case ATA_S_TIMEOUT:
xs->error = XS_TIMEOUT;
  414                 break;
  415         default:
panic("atascsi_disk_cmd_done: unexpected ata_xfer state (%d)",
xa->state);
  418         }
xs->resid = xa->resid;
ata_put_xfer(xa);
xs->flags |= ITSDONE;
scsi_done(xs);
  425 }
  427 int
atascsi_disk_inq(struct scsi_xfer *xs)
  429 {
  430         struct scsi_link        *link = xs->sc_link;
  431         struct atascsi          *as = link->adapter_softc;
  432         struct ata_port         *ap = as->as_ports[link->target];
  433         struct ata_xfer         *xa;
xa = ata_setup_identify(ap, xs->flags & SCSI_NOSLEEP);
  436         if (xa == NULL)
  437                 return (NO_CCB);
xa->complete = atascsi_disk_inq_done;
xa->timeout = xs->timeout;
xa->atascsi_private = xs;
  442         if (xs->flags & SCSI_POLL)
xa->flags |= ATA_F_POLL;
  445         return (ata_exec(as, xa));
  446 }
  448 void
atascsi_disk_inq_done(struct ata_xfer *xa)
  450 {
  451         struct scsi_xfer        *xs = xa->atascsi_private;
  452         struct scsi_link        *link = xs->sc_link;
  453         struct atascsi          *as = link->adapter_softc;
  454         struct ata_port         *ap = as->as_ports[link->target];
  455         struct ata_identify     id;
  456         struct scsi_inquiry_data inq;
  457         int                     host_ncqdepth, complete = 0;
  459         switch (xa->state) {
  460         case ATA_S_COMPLETE:
ata_complete_identify(xa, &id);
bzero(&inq, sizeof(inq));
inq.device = T_DIRECT;
inq.version = 2;
inq.response_format = 2;
inq.additional_length = 32;
bcopy("ATA     ", inq.vendor, sizeof(inq.vendor));
bcopy(id.model, inq.product, sizeof(inq.product));
bcopy(id.firmware, inq.revision, sizeof(inq.revision));
bcopy(&inq, xs->data, MIN(sizeof(inq), xs->datalen));
xs->error = XS_NOERROR;
complete = 1;
  476                 break;
  478         case ATA_S_ERROR:
  479         case ATA_S_TIMEOUT:
ata_free_identify(xa);
xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
XS_DRIVER_STUFFUP);
  483                 break;
  485         default:
panic("atascsi_disk_inq_done: unexpected ata_xfer state (%d)",
xa->state);
  488         }
xs->flags |= ITSDONE;
scsi_done(xs);
  493         if (!complete || (ap->ap_features & ATA_PORT_F_PROBED))
  494                 return;
ap->ap_features = ATA_PORT_F_PROBED;
  498         if (as->as_capability & ASAA_CAP_NCQ && (letoh16(id.satacap) &
  499             (1 << 8))) {
  500                 /*
  501                  * At this point, openings should be the number of commands the
  502                  * host controller supports, less the one that is outstanding
  503                  * as a result of this inquiry, less any reserved slot the 
  504                  * host controller needs for recovery.
  505                  */
host_ncqdepth = link->openings + 1 + ((as->as_capability &
ASAA_CAP_NEEDS_RESERVED) ? 1 : 0);
ap->ap_ncqdepth = (letoh16(id.qdepth) & 0x1f) + 1;
  511                 /* Limit the number of openings to what the device supports. */
  512                 if (host_ncqdepth > ap->ap_ncqdepth)
link->openings -= (host_ncqdepth - ap->ap_ncqdepth);
  515                 /*
  516                  * XXX throw away any xfers that have tag numbers higher than
  517                  * what the device supports.
  518                  */
  519                 while (host_ncqdepth--) {
  520                         struct ata_xfer *xa;
xa = ata_get_xfer(ap, 1);
  523                         if (xa->tag < ap->ap_ncqdepth) {
xa->state = ATA_S_COMPLETE;
ata_put_xfer(xa);
  526                         }
  527                 }
  528         }
  529 }
  531 int
atascsi_disk_sync(struct scsi_xfer *xs)
  533 {
  534         struct scsi_link        *link = xs->sc_link;
  535         struct atascsi          *as = link->adapter_softc;
  536         struct ata_port         *ap = as->as_ports[link->target];
  537         struct ata_xfer         *xa;
  538         int                     s;
s = splbio();
xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
splx(s);
  543         if (xa == NULL)
  544                 return (NO_CCB);
xa->datalen = 0;
xa->flags = ATA_F_READ;
xa->complete = atascsi_disk_sync_done;
  549         /* Spec says flush cache can take >30 sec, so give it at least 45. */
xa->timeout = (xs->timeout < 45000) ? 45000 : xs->timeout;
xa->atascsi_private = xs;
  552         if (xs->flags & SCSI_POLL)
xa->flags |= ATA_F_POLL;
xa->fis->flags = ATA_H2D_FLAGS_CMD;
xa->fis->command = ATA_C_FLUSH_CACHE;
xa->fis->device = 0;
  559         return (ata_exec(as, xa));
  560 }
  562 void
atascsi_disk_sync_done(struct ata_xfer *xa)
  564 {
  565         struct scsi_xfer        *xs = xa->atascsi_private;
  567         switch (xa->state) {
  568         case ATA_S_COMPLETE:
xs->error = XS_NOERROR;
  570                 break;
  572         case ATA_S_ERROR:
  573         case ATA_S_TIMEOUT:
printf("atascsi_disk_sync_done: %s\n",
xa->state == ATA_S_TIMEOUT ? "timeout" : "error");
xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
XS_DRIVER_STUFFUP);
  578                 break;
  580         default:
panic("atascsi_disk_sync_done: unexpected ata_xfer state (%d)",
xa->state);
  583         }
ata_put_xfer(xa);
xs->flags |= ITSDONE;
scsi_done(xs);
  589 }
  591 int
atascsi_disk_capacity(struct scsi_xfer *xs)
  593 {
  594         struct scsi_link        *link = xs->sc_link;
  595         struct atascsi          *as = link->adapter_softc;
  596         struct ata_port         *ap = as->as_ports[link->target];
  597         struct ata_xfer         *xa;
xa = ata_setup_identify(ap, xs->flags & SCSI_NOSLEEP);
  600         if (xa == NULL)
  601                 return (NO_CCB);
xa->complete = atascsi_disk_capacity_done;
xa->timeout = xs->timeout;
xa->atascsi_private = xs;
  606         if (xs->flags & SCSI_POLL)
xa->flags |= ATA_F_POLL;
  609         return (ata_exec(as, xa));
  610 }
  612 void
atascsi_disk_capacity_done(struct ata_xfer *xa)
  614 {
  615         struct scsi_xfer        *xs = xa->atascsi_private;
  616         struct ata_identify     id;
  617         struct scsi_read_cap_data rcd;
u_int64_t               capacity;
  619         int                     i;
  621         switch (xa->state) {
  622         case ATA_S_COMPLETE:
ata_complete_identify(xa, &id);
bzero(&rcd, sizeof(rcd));
  626                 if (letoh16(id.cmdset83) & 0x0400) {
  627                         /* LBA48 feature set supported */
  628                         for (i = 3; i >= 0; --i) {
capacity <<= 16;
capacity += letoh16(id.addrsecxt[i]);
  631                         }
  632                 } else {
capacity = letoh16(id.addrsec[1]);
capacity <<= 16;
capacity += letoh16(id.addrsec[0]);
  636                 }
  638                 /* XXX SCSI layer can't handle a device this big yet */
  639                 if (capacity > 0xffffffff)
capacity = 0xffffffff;
_lto4b(capacity - 1, rcd.addr);
_lto4b(512, rcd.length);
bcopy(&rcd, xs->data, MIN(sizeof(rcd), xs->datalen));
xs->error = XS_NOERROR;
  647                 break;
  649         case ATA_S_ERROR:
  650         case ATA_S_TIMEOUT:
ata_free_identify(xa);
xs->error = (xa->state == ATA_S_TIMEOUT ? XS_TIMEOUT :
XS_DRIVER_STUFFUP);
  654                 break;
  656         default:
panic("atascsi_disk_capacity_done: "
  658                     "unexpected ata_xfer state (%d)", xa->state);
  659         }
xs->flags |= ITSDONE;
scsi_done(xs);
  663 }
  665 int
atascsi_disk_sense(struct scsi_xfer *xs)
  667 {
  668         struct scsi_sense_data  *sd = (struct scsi_sense_data *)xs->data;
  669         int                     s;
bzero(xs->data, xs->datalen);
  672         /* check datalen > sizeof(struct scsi_sense_data)? */
sd->error_code = 0x70; /* XXX magic */
sd->flags = SKEY_NO_SENSE;
xs->error = XS_NOERROR;
xs->flags |= ITSDONE;
s = splbio();
scsi_done(xs);
splx(s);
  682         return (COMPLETE);
  683 }
  685 int
atascsi_atapi_cmd(struct scsi_xfer *xs)
  687 {
  688         struct scsi_link        *link = xs->sc_link;
  689         struct atascsi          *as = link->adapter_softc;
  690         struct ata_port         *ap = as->as_ports[link->target];
  691         int                     s;
  692         struct ata_xfer         *xa;
  693         struct ata_fis_h2d      *fis;
s = splbio();
xa = ata_get_xfer(ap, xs->flags & SCSI_NOSLEEP);
splx(s);
  698         if (xa == NULL)
  699                 return (NO_CCB);
  701         switch (xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
  702         case SCSI_DATA_IN:
xa->flags = ATA_F_PACKET | ATA_F_READ;
  704                 break;
  705         case SCSI_DATA_OUT:
xa->flags = ATA_F_PACKET | ATA_F_WRITE;
  707                 break;
  708         default:
xa->flags = ATA_F_PACKET;
  710         }
xa->data = xs->data;
xa->datalen = xs->datalen;
xa->complete = atascsi_atapi_cmd_done;
xa->timeout = xs->timeout;
xa->atascsi_private = xs;
  717         if (xs->flags & SCSI_POLL)
xa->flags |= ATA_F_POLL;
fis = xa->fis;
fis->flags = ATA_H2D_FLAGS_CMD;
fis->command = ATA_C_PACKET;
fis->device = 0;
fis->sector_count = xa->tag << 3;
fis->features = ATA_H2D_FEATURES_DMA | ((xa->flags & ATA_F_WRITE) ?
ATA_H2D_FEATURES_DIR_WRITE : ATA_H2D_FEATURES_DIR_READ);
fis->lba_mid = 0x00;
fis->lba_high = 0x20;
  730         /* Copy SCSI command into ATAPI packet. */
memcpy(xa->packetcmd, xs->cmd, xs->cmdlen);
  733         return (ata_exec(as, xa));
  734 }
  736 void
atascsi_atapi_cmd_done(struct ata_xfer *xa)
  738 {
  739         struct scsi_xfer        *xs = xa->atascsi_private;
  740         struct scsi_sense_data  *sd = &xs->sense;
  742         switch (xa->state) {
  743         case ATA_S_COMPLETE:
xs->error = XS_NOERROR;
  745                 break;
  746         case ATA_S_ERROR:
  747                 /* Return PACKET sense data */
sd->error_code = SSD_ERRCODE_CURRENT;
sd->flags = (xa->rfis.error & 0xf0) >> 4;
  750                 if (xa->rfis.error & 0x04)
sd->flags = SKEY_ILLEGAL_REQUEST;
  752                 if (xa->rfis.error & 0x02)
sd->flags |= SSD_EOM;
  754                 if (xa->rfis.error & 0x01)
sd->flags |= SSD_ILI;
xs->error = XS_SENSE;
  757                 break;
  758         case ATA_S_TIMEOUT:
printf("atascsi_atapi_cmd_done, timeout\n");
xs->error = XS_TIMEOUT;
  761                 break;
  762         default:
panic("atascsi_atapi_cmd_done: unexpected ata_xfer state (%d)",
xa->state);
  765         }
xs->resid = xa->resid;
ata_put_xfer(xa);
xs->flags |= ITSDONE;
scsi_done(xs);
  772 }
  774 int
atascsi_stuffup(struct scsi_xfer *xs)
  776 {
  777         int                     s;
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
s = splbio();
scsi_done(xs);
splx(s);
  785         return (COMPLETE);
  786 }
  788 int
ata_exec(struct atascsi *as, struct ata_xfer *xa)
  790 {
  791         int polled = xa->flags & ATA_F_POLL;
  793         switch (as->as_methods->ata_cmd(xa)) {
  794         case ATA_COMPLETE:
  795         case ATA_ERROR:
  796                 return (COMPLETE);
  797         case ATA_QUEUED:
  798                 if (!polled)
  799                         return (SUCCESSFULLY_QUEUED);
  800         default:
panic("unexpected return from ata_exec");
  802         }
  803 }
  805 struct ata_xfer *
ata_get_xfer(struct ata_port *ap, int nosleep /* XXX unused */)
  807 {
  808         struct atascsi          *as = ap->ap_as;
  809         struct ata_xfer         *xa;
xa = as->as_methods->ata_get_xfer(as->as_cookie, ap->ap_port);
  812         if (xa != NULL)
xa->fis->type = ATA_FIS_TYPE_H2D;
  815         return (xa);
  816 }
  818 void
ata_put_xfer(struct ata_xfer *xa)
  820 {
xa->ata_put_xfer(xa);
  822 }