/*
* Open the device. Make sure the partition info is as up-to-date as can be.
*/
int
sdopen(dev_t dev, int flag, int fmt, struct proc *p)
{
struct scsi_link *sc_link;
struct sd_softc *sc;
int error = 0, part, rawopen, unit;
unit = DISKUNIT(dev);
part = DISKPART(dev);
rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
sc = sdlookup(unit);
if (sc == NULL)
return (ENXIO);
sc_link = sc->sc_link;
if (sc->flags & SDF_DYING) {
device_unref(&sc->sc_dev);
return (ENXIO);
}
if (ISSET(flag, FWRITE) && ISSET(sc_link->flags, SDEV_READONLY)) {
device_unref(&sc->sc_dev);
return (EACCES);
}
SC_DEBUG(sc_link, SDEV_DB1,
("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
sd_cd.cd_ndevs, part));
if ((error = disk_lock(&sc->sc_dk)) != 0) {
device_unref(&sc->sc_dev);
return (error);
}
if (sc->sc_dk.dk_openmask != 0) {
/*
* If any partition is open, but the disk has been invalidated,
* disallow further opens of non-raw partition.
*/
if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
if (rawopen)
goto out;
error = EIO;
goto bad;
}
} else {
/* Spin up non-UMASS devices ready or not. */
if ((sc->sc_link->flags & SDEV_UMASS) == 0)
scsi_start(sc_link, SSS_START, (rawopen ? SCSI_SILENT :
0) | SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
/* Use sd_interpret_sense() for sense errors.
*
* But only after spinning the disk up! Just in case a broken
* device returns "Initialization command required." and causes
* a loop of scsi_start() calls.
*/
sc_link->flags |= SDEV_OPEN;
/*
* Try to prevent the unloading of a removable device while
* it's open. But allow the open to proceed if the device can't
* be locked in.
*/
if ((sc_link->flags & SDEV_REMOVABLE) != 0) {
scsi_prevent(sc_link, PR_PREVENT, SCSI_SILENT |
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
}
/* Check that it is still responding and ok. */
error = scsi_test_unit_ready(sc_link,
TEST_READY_RETRIES, SCSI_SILENT |
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
if (error) {
if (rawopen) {
error = 0;
goto out;
} else
goto bad;
}
/* Load the physical device parameters. */
sc_link->flags |= SDEV_MEDIA_LOADED;
if (sd_get_parms(sc, &sc->params, (rawopen ? SCSI_SILENT : 0))
== SDGP_RESULT_OFFLINE) {
sc_link->flags &= ~SDEV_MEDIA_LOADED;
error = ENXIO;
goto bad;
}
SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
/* Load the partition info if not already loaded. */
if (sdgetdisklabel(dev, sc, sc->sc_dk.dk_label, 0) == EIO) {
error = EIO;
goto bad;
}
SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded\n"));
}
out:
if ((error = disk_openpart(&sc->sc_dk, part, fmt, 1)) != 0)
goto bad;
SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
/* It's OK to fall through because dk_openmask is now non-zero. */
bad:
if (sc->sc_dk.dk_openmask == 0) {
if ((sc->sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sc_link, PR_ALLOW, SCSI_SILENT |
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
}
disk_unlock(&sc->sc_dk);
device_unref(&sc->sc_dev);
return (error);
}
/*
* Perform special action on behalf of the user
* Knows about the internals of this device
*/
int
sdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
{
struct sd_softc *sc;
struct disklabel *lp;
int error = 0;
int part = DISKPART(dev);
sc = sdlookup(DISKUNIT(dev));
if (sc == NULL)
return (ENXIO);
if (sc->flags & SDF_DYING) {
device_unref(&sc->sc_dev);
return (ENXIO);
}
SC_DEBUG(sc->sc_link, SDEV_DB2, ("sdioctl 0x%lx\n", cmd));
/*
* If the device is not valid.. abandon ship
*/
if ((sc->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
switch (cmd) {
case DIOCLOCK:
case DIOCEJECT:
case SCIOCIDENTIFY:
case SCIOCCOMMAND:
case SCIOCDEBUG:
if (part == RAW_PART)
break;
/* FALLTHROUGH */
default:
if ((sc->sc_link->flags & SDEV_OPEN) == 0) {
error = ENODEV;
goto exit;
} else {
error = EIO;
goto exit;
}
}
}
switch (cmd) {
case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
sdgetdisklabel(dev, sc, lp, 0);
bcopy(lp, sc->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
goto exit;
case DIOCGPDINFO:
sdgetdisklabel(dev, sc, (struct disklabel *)addr, 1);
goto exit;
case DIOCGDINFO:
*(struct disklabel *)addr = *(sc->sc_dk.dk_label);
goto exit;
case DIOCGPART:
((struct partinfo *)addr)->disklab = sc->sc_dk.dk_label;
((struct partinfo *)addr)->part =
&sc->sc_dk.dk_label->d_partitions[DISKPART(dev)];
goto exit;
case DIOCWDINFO:
case DIOCSDINFO:
if ((flag & FWRITE) == 0) {
error = EBADF;
goto exit;
}
if ((error = disk_lock(&sc->sc_dk)) != 0)
goto exit;
error = setdisklabel(sc->sc_dk.dk_label,
(struct disklabel *)addr, sc->sc_dk.dk_openmask);
if (error == 0) {
if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
sdstrategy, sc->sc_dk.dk_label);
}
disk_unlock(&sc->sc_dk);
goto exit;
case DIOCLOCK:
error = scsi_prevent(sc->sc_link,
(*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
goto exit;
case MTIOCTOP:
if (((struct mtop *)addr)->mt_op != MTOFFL) {
error = EIO;
goto exit;
}
/* FALLTHROUGH */
case DIOCEJECT:
if ((sc->sc_link->flags & SDEV_REMOVABLE) == 0) {
error = ENOTTY;
goto exit;
}
sc->sc_link->flags |= SDEV_EJECTING;
goto exit;
case DIOCINQ:
error = scsi_do_ioctl(sc->sc_link, cmd, addr, flag);
if (error == ENOTTY)
error = sd_ioctl_inquiry(sc,
(struct dk_inquiry *)addr);
goto exit;
case DIOCSCACHE:
if (!ISSET(flag, FWRITE)) {
error = EBADF;
goto exit;
}
/* FALLTHROUGH */
case DIOCGCACHE:
error = sd_ioctl_cache(sc, cmd, (struct dk_cache *)addr);
goto exit;
case DIOCCACHESYNC:
if (!ISSET(flag, FWRITE)) {
error = EBADF;
goto exit;
}
if ((sc->flags & SDF_DIRTY) != 0 || *(int *)addr != 0)
error = sd_flush(sc, 0);
return (error);
default:
if (part != RAW_PART) {
error = ENOTTY;
goto exit;
}
error = scsi_do_ioctl(sc->sc_link, cmd, addr, flag);
}
exit:
device_unref(&sc->sc_dev);
return (error);
}
/*
* Open device (read drive parameters and disklabel)
*/
int
sdopen(struct open_file *f, ...)
{
struct sd_softc *sd;
struct scsi_test_unit_ready cmd;
struct scsipi_inquiry_data *inqbuf;
u_int bus, target, lun, part;
int error;
char buf[SCSIPI_INQUIRY_LENGTH_SCSI2];
va_list ap;
va_start(ap, f);
bus = 0;
target = va_arg(ap, u_int);
lun = va_arg(ap, u_int);
part = va_arg(ap, u_int);
va_end(ap);
DPRINTF(("sdopen: sd(%d,%d,%d)\n", target, lun, part));
sd = alloc(sizeof(struct sd_softc));
if (sd == NULL)
return ENOMEM;
memset(sd, 0, sizeof(struct sd_softc));
sd->sc_part = part;
sd->sc_lun = lun;
sd->sc_target = target;
sd->sc_bus = bus;
if ((error = scsi_inquire(sd, sizeof(buf), buf)) != 0)
return error;
inqbuf = (struct scsipi_inquiry_data *)buf;
sd->sc_type = inqbuf->device & SID_TYPE;
/*
* Determine the operating mode capabilities of the device.
*/
if ((inqbuf->version & SID_ANSII) >= 2) {
// if ((inqbuf->flags3 & SID_CmdQue) != 0)
// sd->sc_cap |= PERIPH_CAP_TQING;
if ((inqbuf->flags3 & SID_Sync) != 0)
sd->sc_cap |= PERIPH_CAP_SYNC;
/* SPC-2 */
if ((inqbuf->version & SID_ANSII) >= 3) {
/*
* Report ST clocking though CAP_WIDExx/CAP_SYNC.
* If the device only supports DT, clear these
* flags (DT implies SYNC and WIDE)
*/
switch (inqbuf->flags4 & SID_Clocking) {
case SID_CLOCKING_DT_ONLY:
sd->sc_cap &= ~PERIPH_CAP_SYNC;
break;
}
}
}
sd->sc_flags =
(inqbuf->dev_qual2 & SID_REMOVABLE) ? FLAGS_REMOVABLE : 0;
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = SCSI_TEST_UNIT_READY;
if ((error = scsi_command(sd, (void *)&cmd, sizeof(cmd), NULL, 0)) != 0)
return error;
if (sd->sc_flags & FLAGS_REMOVABLE) {
printf("XXXXX: removable device found. will not support\n");
}
if (!(sd->sc_flags & FLAGS_MEDIA_LOADED))
sd->sc_flags |= FLAGS_MEDIA_LOADED;
if ((error = sd_get_parms(sd)) != 0)
return error;
strncpy(sd->sc_label.d_typename, inqbuf->product, 16);
if ((error = sdgetdisklabel(sd)) != 0)
return error;
f->f_devdata = sd;
return 0;
}
