357 lines
9.4 KiB
C
357 lines
9.4 KiB
C
/* $OpenBSD: scsi_ioctl.c,v 1.67 2020/09/22 19:32:53 krw Exp $ */
|
|
/* $NetBSD: scsi_ioctl.c,v 1.23 1996/10/12 23:23:17 christos Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1994 Charles Hannum. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Charles Hannum.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* Contributed by HD Associates (hd@world.std.com).
|
|
* Copyright (c) 1992, 1993 HD Associates
|
|
*
|
|
* Berkeley style copyright.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/pool.h>
|
|
#include <sys/device.h>
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <scsi/scsi_all.h>
|
|
#include <scsi/scsi_debug.h>
|
|
#include <scsi/scsiconf.h>
|
|
|
|
#include <sys/scsiio.h>
|
|
#include <sys/ataio.h>
|
|
|
|
int scsi_ioc_cmd(struct scsi_link *, scsireq_t *);
|
|
int scsi_ioc_ata_cmd(struct scsi_link *, atareq_t *);
|
|
|
|
const unsigned char scsi_readsafe_cmd[256] = {
|
|
[0x00] = 1, /* TEST UNIT READY */
|
|
[0x03] = 1, /* REQUEST SENSE */
|
|
[0x08] = 1, /* READ(6) */
|
|
[0x12] = 1, /* INQUIRY */
|
|
[0x1a] = 1, /* MODE SENSE */
|
|
[0x1b] = 1, /* START STOP */
|
|
[0x23] = 1, /* READ FORMAT CAPACITIES */
|
|
[0x25] = 1, /* READ CDVD CAPACITY */
|
|
[0x28] = 1, /* READ(10) */
|
|
[0x2b] = 1, /* SEEK */
|
|
[0x2f] = 1, /* VERIFY(10) */
|
|
[0x3c] = 1, /* READ BUFFER */
|
|
[0x3e] = 1, /* READ LONG */
|
|
[0x42] = 1, /* READ SUBCHANNEL */
|
|
[0x43] = 1, /* READ TOC PMA ATIP */
|
|
[0x44] = 1, /* READ HEADER */
|
|
[0x45] = 1, /* PLAY AUDIO(10) */
|
|
[0x46] = 1, /* GET CONFIGURATION */
|
|
[0x47] = 1, /* PLAY AUDIO MSF */
|
|
[0x48] = 1, /* PLAY AUDIO TI */
|
|
[0x4a] = 1, /* GET EVENT STATUS NOTIFICATION */
|
|
[0x4b] = 1, /* PAUSE RESUME */
|
|
[0x4e] = 1, /* STOP PLAY SCAN */
|
|
[0x51] = 1, /* READ DISC INFO */
|
|
[0x52] = 1, /* READ TRACK RZONE INFO */
|
|
[0x5a] = 1, /* MODE SENSE(10) */
|
|
[0x88] = 1, /* READ(16) */
|
|
[0x8f] = 1, /* VERIFY(16) */
|
|
[0xa4] = 1, /* REPORT KEY */
|
|
[0xa5] = 1, /* PLAY AUDIO(12) */
|
|
[0xa8] = 1, /* READ(12) */
|
|
[0xac] = 1, /* GET PERFORMANCE */
|
|
[0xad] = 1, /* READ DVD STRUCTURE */
|
|
[0xb9] = 1, /* READ CD MSF */
|
|
[0xba] = 1, /* SCAN */
|
|
[0xbc] = 1, /* PLAY CD */
|
|
[0xbd] = 1, /* MECHANISM STATUS */
|
|
[0xbe] = 1 /* READ CD */
|
|
};
|
|
|
|
int
|
|
scsi_ioc_cmd(struct scsi_link *link, scsireq_t *screq)
|
|
{
|
|
struct scsi_xfer *xs;
|
|
int err = 0;
|
|
|
|
if (screq->cmdlen > sizeof(struct scsi_generic))
|
|
return EFAULT;
|
|
if (screq->datalen > MAXPHYS)
|
|
return EINVAL;
|
|
|
|
xs = scsi_xs_get(link, 0);
|
|
if (xs == NULL)
|
|
return ENOMEM;
|
|
|
|
memcpy(&xs->cmd, screq->cmd, screq->cmdlen);
|
|
xs->cmdlen = screq->cmdlen;
|
|
|
|
if (screq->datalen > 0) {
|
|
xs->data = dma_alloc(screq->datalen, PR_WAITOK | PR_ZERO);
|
|
if (xs->data == NULL) {
|
|
err = ENOMEM;
|
|
goto err;
|
|
}
|
|
xs->datalen = screq->datalen;
|
|
}
|
|
|
|
if (ISSET(screq->flags, SCCMD_READ))
|
|
SET(xs->flags, SCSI_DATA_IN);
|
|
if (ISSET(screq->flags, SCCMD_WRITE)) {
|
|
if (screq->datalen > 0) {
|
|
err = copyin(screq->databuf, xs->data, screq->datalen);
|
|
if (err != 0)
|
|
goto err;
|
|
}
|
|
|
|
SET(xs->flags, SCSI_DATA_OUT);
|
|
}
|
|
|
|
SET(xs->flags, SCSI_SILENT); /* User is responsible for errors. */
|
|
xs->timeout = screq->timeout;
|
|
xs->retries = 0; /* user must do the retries *//* ignored */
|
|
|
|
scsi_xs_sync(xs);
|
|
|
|
screq->retsts = 0;
|
|
screq->status = xs->status;
|
|
switch (xs->error) {
|
|
case XS_NOERROR:
|
|
/* probably rubbish */
|
|
screq->datalen_used = xs->datalen - xs->resid;
|
|
screq->retsts = SCCMD_OK;
|
|
break;
|
|
case XS_SENSE:
|
|
SC_DEBUG_SENSE(xs);
|
|
screq->senselen_used = min(sizeof(xs->sense),
|
|
sizeof(screq->sense));
|
|
memcpy(screq->sense, &xs->sense, screq->senselen_used);
|
|
screq->retsts = SCCMD_SENSE;
|
|
break;
|
|
case XS_SHORTSENSE:
|
|
SC_DEBUG_SENSE(xs);
|
|
printf("XS_SHORTSENSE\n");
|
|
screq->senselen_used = min(sizeof(xs->sense),
|
|
sizeof(screq->sense));
|
|
memcpy(screq->sense, &xs->sense, screq->senselen_used);
|
|
screq->retsts = SCCMD_UNKNOWN;
|
|
break;
|
|
case XS_DRIVER_STUFFUP:
|
|
screq->retsts = SCCMD_UNKNOWN;
|
|
break;
|
|
case XS_TIMEOUT:
|
|
screq->retsts = SCCMD_TIMEOUT;
|
|
break;
|
|
case XS_BUSY:
|
|
screq->retsts = SCCMD_BUSY;
|
|
break;
|
|
default:
|
|
screq->retsts = SCCMD_UNKNOWN;
|
|
break;
|
|
}
|
|
|
|
if (screq->datalen > 0 && ISSET(screq->flags, SCCMD_READ)) {
|
|
err = copyout(xs->data, screq->databuf, screq->datalen);
|
|
if (err != 0)
|
|
goto err;
|
|
}
|
|
|
|
err:
|
|
if (xs->data)
|
|
dma_free(xs->data, screq->datalen);
|
|
scsi_xs_put(xs);
|
|
|
|
return err;
|
|
}
|
|
|
|
int
|
|
scsi_ioc_ata_cmd(struct scsi_link *link, atareq_t *atareq)
|
|
{
|
|
struct scsi_xfer *xs;
|
|
struct scsi_ata_passthru_12 *cdb;
|
|
int err = 0;
|
|
|
|
if (atareq->datalen > MAXPHYS)
|
|
return EINVAL;
|
|
|
|
xs = scsi_xs_get(link, 0);
|
|
if (xs == NULL)
|
|
return ENOMEM;
|
|
|
|
cdb = (struct scsi_ata_passthru_12 *)&xs->cmd;
|
|
cdb->opcode = ATA_PASSTHRU_12;
|
|
|
|
if (atareq->datalen > 0) {
|
|
if (ISSET(atareq->flags, ATACMD_READ)) {
|
|
cdb->count_proto = ATA_PASSTHRU_PROTO_PIO_DATAIN;
|
|
cdb->flags = ATA_PASSTHRU_T_DIR_READ;
|
|
} else {
|
|
cdb->count_proto = ATA_PASSTHRU_PROTO_PIO_DATAOUT;
|
|
cdb->flags = ATA_PASSTHRU_T_DIR_WRITE;
|
|
}
|
|
SET(cdb->flags, ATA_PASSTHRU_T_LEN_SECTOR_COUNT);
|
|
} else {
|
|
cdb->count_proto = ATA_PASSTHRU_PROTO_NON_DATA;
|
|
cdb->flags = ATA_PASSTHRU_T_LEN_NONE;
|
|
}
|
|
cdb->features = atareq->features;
|
|
cdb->sector_count = atareq->sec_count;
|
|
cdb->lba_low = atareq->sec_num;
|
|
cdb->lba_mid = atareq->cylinder;
|
|
cdb->lba_high = atareq->cylinder >> 8;
|
|
cdb->device = atareq->head & 0x0f;
|
|
cdb->command = atareq->command;
|
|
|
|
xs->cmdlen = sizeof(*cdb);
|
|
|
|
if (atareq->datalen > 0) {
|
|
xs->data = dma_alloc(atareq->datalen, PR_WAITOK | PR_ZERO);
|
|
if (xs->data == NULL) {
|
|
err = ENOMEM;
|
|
goto err;
|
|
}
|
|
xs->datalen = atareq->datalen;
|
|
}
|
|
|
|
if (ISSET(atareq->flags, ATACMD_READ))
|
|
SET(xs->flags, SCSI_DATA_IN);
|
|
if (ISSET(atareq->flags, ATACMD_WRITE)) {
|
|
if (atareq->datalen > 0) {
|
|
err = copyin(atareq->databuf, xs->data,
|
|
atareq->datalen);
|
|
if (err != 0)
|
|
goto err;
|
|
}
|
|
|
|
SET(xs->flags, SCSI_DATA_OUT);
|
|
}
|
|
|
|
SET(xs->flags, SCSI_SILENT); /* User is responsible for errors. */
|
|
xs->retries = 0; /* user must do the retries *//* ignored */
|
|
|
|
scsi_xs_sync(xs);
|
|
|
|
atareq->retsts = ATACMD_ERROR;
|
|
switch (xs->error) {
|
|
case XS_SENSE:
|
|
case XS_SHORTSENSE:
|
|
SC_DEBUG_SENSE(xs);
|
|
/* XXX this is not right */
|
|
case XS_NOERROR:
|
|
atareq->retsts = ATACMD_OK;
|
|
break;
|
|
default:
|
|
atareq->retsts = ATACMD_ERROR;
|
|
break;
|
|
}
|
|
|
|
if (atareq->datalen > 0 && ISSET(atareq->flags, ATACMD_READ)) {
|
|
err = copyout(xs->data, atareq->databuf, atareq->datalen);
|
|
if (err != 0)
|
|
goto err;
|
|
}
|
|
|
|
err:
|
|
if (xs->data)
|
|
dma_free(xs->data, atareq->datalen);
|
|
scsi_xs_put(xs);
|
|
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Something (e.g. another driver) has called us
|
|
* with a scsi_link for a target/lun/adapter, and a scsi
|
|
* specific ioctl to perform, better try.
|
|
*/
|
|
int
|
|
scsi_do_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag)
|
|
{
|
|
SC_DEBUG(link, SDEV_DB2, ("scsi_do_ioctl(0x%lx)\n", cmd));
|
|
|
|
switch(cmd) {
|
|
case SCIOCIDENTIFY: {
|
|
struct scsi_addr *sca = (struct scsi_addr *)addr;
|
|
|
|
if (!ISSET(link->flags, (SDEV_ATAPI | SDEV_UMASS)))
|
|
/* A 'real' SCSI target. */
|
|
sca->type = TYPE_SCSI;
|
|
else
|
|
/* An 'emulated' SCSI target. */
|
|
sca->type = TYPE_ATAPI;
|
|
sca->scbus = link->bus->sc_dev.dv_unit;
|
|
sca->target = link->target;
|
|
sca->lun = link->lun;
|
|
return 0;
|
|
}
|
|
case SCIOCCOMMAND:
|
|
if (scsi_readsafe_cmd[((scsireq_t *)addr)->cmd[0]])
|
|
break;
|
|
/* FALLTHROUGH */
|
|
case ATAIOCCOMMAND:
|
|
case SCIOCDEBUG:
|
|
if (!ISSET(flag, FWRITE))
|
|
return EPERM;
|
|
break;
|
|
default:
|
|
if (link->bus->sb_adapter->ioctl)
|
|
return (link->bus->sb_adapter->ioctl)(link, cmd, addr, flag);
|
|
else
|
|
return ENOTTY;
|
|
}
|
|
|
|
switch(cmd) {
|
|
case SCIOCCOMMAND:
|
|
return scsi_ioc_cmd(link, (scsireq_t *)addr);
|
|
case ATAIOCCOMMAND:
|
|
return scsi_ioc_ata_cmd(link, (atareq_t *)addr);
|
|
case SCIOCDEBUG: {
|
|
int level = *((int *)addr);
|
|
|
|
SC_DEBUG(link, SDEV_DB3, ("debug set to %d\n", level));
|
|
CLR(link->flags, SDEV_DBX); /* clear debug bits */
|
|
if (level & 1)
|
|
SET(link->flags, SDEV_DB1);
|
|
if (level & 2)
|
|
SET(link->flags, SDEV_DB2);
|
|
if (level & 4)
|
|
SET(link->flags, SDEV_DB3);
|
|
if (level & 8)
|
|
SET(link->flags, SDEV_DB4);
|
|
return 0;
|
|
}
|
|
default:
|
|
#ifdef DIAGNOSTIC
|
|
panic("scsi_do_ioctl: impossible cmd (%#lx)", cmd);
|
|
#endif /* DIAGNOSTIC */
|
|
return 0;
|
|
}
|
|
}
|