/*
* sd_read_capacity:
*
* Find out from the device what its capacity is.
*/
static uint64_t
sd_read_capacity(struct sd_softc *sd, int *blksize)
{
union {
struct scsipi_read_capacity_10 cmd;
struct scsipi_read_capacity_16 cmd16;
} cmd;
union {
struct scsipi_read_capacity_10_data data;
struct scsipi_read_capacity_16_data data16;
} data;
uint64_t rv;
memset(&cmd, 0, sizeof(cmd));
cmd.cmd.opcode = READ_CAPACITY_10;
/*
* If the command works, interpret the result as a 4 byte
* number of blocks
*/
rv = 0;
memset(&data, 0, sizeof(data.data));
if (scsi_command(sd, (void *)&cmd.cmd, sizeof(cmd.cmd),
(void *)&data, sizeof(data.data)) != 0)
goto out;
if (_4btol(data.data.addr) != 0xffffffff) {
*blksize = _4btol(data.data.length);
rv = _4btol(data.data.addr) + 1;
goto out;
}
/*
* Device is larger than can be reflected by READ CAPACITY (10).
* Try READ CAPACITY (16).
*/
memset(&cmd, 0, sizeof(cmd));
cmd.cmd16.opcode = READ_CAPACITY_16;
cmd.cmd16.byte2 = SRC16_SERVICE_ACTION;
_lto4b(sizeof(data.data16), cmd.cmd16.len);
memset(&data, 0, sizeof(data.data16));
if (scsi_command(sd, (void *)&cmd.cmd16, sizeof(cmd.cmd16),
(void *)&data, sizeof(data.data16)) != 0)
goto out;
*blksize = _4btol(data.data16.length);
rv = _8btol(data.data16.addr) + 1;
out:
return rv;
}
int
sd_read_cap_16(struct sd_softc *sc, int flags)
{
struct scsi_read_capacity_16 cdb;
struct scsi_read_cap_data_16 *rdcap;
struct scsi_xfer *xs;
int rv = ENOMEM;
CLR(flags, SCSI_IGNORE_ILLEGAL_REQUEST);
rdcap = dma_alloc(sizeof(*rdcap), (ISSET(flags, SCSI_NOSLEEP) ?
PR_NOWAIT : PR_WAITOK) | PR_ZERO);
if (rdcap == NULL)
return (ENOMEM);
xs = scsi_xs_get(sc->sc_link, flags | SCSI_DATA_IN | SCSI_SILENT);
if (xs == NULL)
goto done;
bzero(&cdb, sizeof(cdb));
cdb.opcode = READ_CAPACITY_16;
cdb.byte2 = SRC16_SERVICE_ACTION;
_lto4b(sizeof(*rdcap), cdb.length);
memcpy(xs->cmd, &cdb, sizeof(cdb));
xs->cmdlen = sizeof(cdb);
xs->data = (void *)rdcap;
xs->datalen = sizeof(*rdcap);
xs->timeout = 20000;
rv = scsi_xs_sync(xs);
scsi_xs_put(xs);
if (rv == 0) {
sc->params.disksize = _8btol(rdcap->addr) + 1;
sc->params.secsize = _4btol(rdcap->length);
if (ISSET(_2btol(rdcap->lowest_aligned), READ_CAP_16_TPE))
SET(sc->flags, SDF_THIN);
else
CLR(sc->flags, SDF_THIN);
}
done:
dma_free(rdcap, sizeof(*rdcap));
return (rv);
}
void
vdsk_scsi_cmd(struct scsi_xfer *xs)
{
struct scsi_rw *rw;
struct scsi_rw_big *rwb;
struct scsi_rw_12 *rw12;
struct scsi_rw_16 *rw16;
u_int64_t lba;
u_int32_t sector_count;
uint8_t operation;
switch (xs->cmd->opcode) {
case READ_BIG:
case READ_COMMAND:
case READ_12:
case READ_16:
operation = VD_OP_BREAD;
break;
case WRITE_BIG:
case WRITE_COMMAND:
case WRITE_12:
case WRITE_16:
operation = VD_OP_BWRITE;
break;
case SYNCHRONIZE_CACHE:
operation = VD_OP_FLUSH;
break;
case INQUIRY:
vdsk_scsi_inq(xs);
return;
case READ_CAPACITY:
vdsk_scsi_capacity(xs);
return;
case READ_CAPACITY_16:
vdsk_scsi_capacity16(xs);
return;
case TEST_UNIT_READY:
case START_STOP:
case PREVENT_ALLOW:
vdsk_scsi_done(xs, XS_NOERROR);
return;
default:
printf("%s cmd 0x%02x\n", __func__, xs->cmd->opcode);
case MODE_SENSE:
case MODE_SENSE_BIG:
case REPORT_LUNS:
case READ_TOC:
vdsk_scsi_done(xs, XS_DRIVER_STUFFUP);
return;
}
/*
* READ/WRITE/SYNCHRONIZE commands. SYNCHRONIZE CACHE has same
* layout as 10-byte READ/WRITE commands.
*/
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;
} else if (xs->cmdlen == 10) {
rwb = (struct scsi_rw_big *)xs->cmd;
lba = _4btol(rwb->addr);
sector_count = _2btol(rwb->length);
} else if (xs->cmdlen == 12) {
rw12 = (struct scsi_rw_12 *)xs->cmd;
lba = _4btol(rw12->addr);
sector_count = _4btol(rw12->length);
} else if (xs->cmdlen == 16) {
rw16 = (struct scsi_rw_16 *)xs->cmd;
lba = _8btol(rw16->addr);
sector_count = _4btol(rw16->length);
}
{
struct vdsk_softc *sc = xs->sc_link->adapter_softc;
struct ldc_map *map = sc->sc_lm;
struct vio_dring_msg dm;
vaddr_t va;
paddr_t pa;
psize_t nbytes;
int len, ncookies;
int desc, s;
int timeout;
s = splbio();
desc = sc->sc_tx_prod;
ncookies = 0;
len = xs->datalen;
va = (vaddr_t)xs->data;
while (len > 0) {
KASSERT(ncookies < MAXPHYS / PAGE_SIZE);
pmap_extract(pmap_kernel(), va, &pa);
while (map->lm_slot[map->lm_next].entry != 0) {
map->lm_next++;
map->lm_next &= (map->lm_nentries - 1);
}
map->lm_slot[map->lm_next].entry = (pa & LDC_MTE_RA_MASK);
map->lm_slot[map->lm_next].entry |= LDC_MTE_CPR | LDC_MTE_CPW;
map->lm_slot[map->lm_next].entry |= LDC_MTE_IOR | LDC_MTE_IOW;
map->lm_slot[map->lm_next].entry |= LDC_MTE_R | LDC_MTE_W;
map->lm_count++;
nbytes = MIN(len, PAGE_SIZE - (pa & PAGE_MASK));
sc->sc_vd->vd_desc[desc].cookie[ncookies].addr =
map->lm_next << PAGE_SHIFT | (pa & PAGE_MASK);
sc->sc_vd->vd_desc[desc].cookie[ncookies].size = nbytes;
sc->sc_vsd[desc].vsd_map_idx[ncookies] = map->lm_next;
va += nbytes;
len -= nbytes;
ncookies++;
}
sc->sc_vd->vd_desc[desc].hdr.ack = 1;
sc->sc_vd->vd_desc[desc].operation = operation;
sc->sc_vd->vd_desc[desc].slice = VD_SLICE_NONE;
sc->sc_vd->vd_desc[desc].status = 0xffffffff;
sc->sc_vd->vd_desc[desc].offset = lba;
sc->sc_vd->vd_desc[desc].size = xs->datalen;
sc->sc_vd->vd_desc[desc].ncookies = ncookies;
membar(Sync);
sc->sc_vd->vd_desc[desc].hdr.dstate = VIO_DESC_READY;
sc->sc_vsd[desc].vsd_xs = xs;
sc->sc_vsd[desc].vsd_ncookies = ncookies;
sc->sc_tx_prod++;
sc->sc_tx_prod &= (sc->sc_vd->vd_nentries - 1);
bzero(&dm, sizeof(dm));
dm.tag.type = VIO_TYPE_DATA;
dm.tag.stype = VIO_SUBTYPE_INFO;
dm.tag.stype_env = VIO_DRING_DATA;
dm.tag.sid = sc->sc_local_sid;
dm.seq_no = sc->sc_seq_no++;
dm.dring_ident = sc->sc_dring_ident;
dm.start_idx = dm.end_idx = desc;
vdsk_sendmsg(sc, &dm, sizeof(dm));
if (!ISSET(xs->flags, SCSI_POLL)) {
splx(s);
return;
}
timeout = 1000;
do {
if (vdsk_rx_intr(sc) &&
sc->sc_vd->vd_desc[desc].status == VIO_DESC_FREE)
break;
delay(1000);
} while(--timeout > 0);
splx(s);
}
}
