int
vldcpread(dev_t dev, struct uio *uio, int ioflag)
{
struct vldcp_softc *sc;
struct ldc_conn *lc;
uint64_t rx_head, rx_tail, rx_state;
int err, ret;
int s;
sc = vldcp_lookup(dev);
if (sc == NULL)
return (ENXIO);
lc = &sc->sc_lc;
if (uio->uio_resid != 64) {
device_unref(&sc->sc_dv);
return (EINVAL);
}
s = spltty();
retry:
err = hv_ldc_rx_get_state(lc->lc_id, &rx_head, &rx_tail, &rx_state);
if (err != H_EOK) {
splx(s);
printf("%s: hv_ldc_rx_get_state %d\n", __func__, err);
device_unref(&sc->sc_dv);
return (EIO);
}
if (rx_state != LDC_CHANNEL_UP) {
splx(s);
device_unref(&sc->sc_dv);
return (EIO);
}
DPRINTF(("rx head %llx, rx tail %llx\n", rx_head, rx_tail));
if (rx_head == rx_tail) {
cbus_intr_setenabled(sc->sc_rx_sysino, INTR_ENABLED);
ret = tsleep(lc->lc_rxq, PWAIT | PCATCH, "hvrd", 0);
if (ret) {
splx(s);
device_unref(&sc->sc_dv);
return (ret);
}
goto retry;
}
splx(s);
ret = uiomove(lc->lc_rxq->lq_va + rx_head, 64, uio);
rx_head += 64;
rx_head &= ((lc->lc_rxq->lq_nentries * 64) - 1);
err = hv_ldc_rx_set_qhead(lc->lc_id, rx_head);
if (err != H_EOK)
printf("%s: hv_ldc_rx_set_qhead %d\n", __func__, err);
device_unref(&sc->sc_dv);
return (ret);
}
/*
* Actually translate the requested transfer into one the physical driver
* can understand. The transfer is described by a buf and will include
* only one physical transfer.
*/
void
sdstrategy(struct buf *bp)
{
struct sd_softc *sc;
int s;
sc = sdlookup(DISKUNIT(bp->b_dev));
if (sc == NULL) {
bp->b_error = ENXIO;
goto bad;
}
if (sc->flags & SDF_DYING) {
bp->b_error = ENXIO;
goto bad;
}
SC_DEBUG(sc->sc_link, SDEV_DB2, ("sdstrategy: %ld bytes @ blk %lld\n",
bp->b_bcount, (long long)bp->b_blkno));
/*
* If the device has been made invalid, error out
*/
if ((sc->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
if (sc->sc_link->flags & SDEV_OPEN)
bp->b_error = EIO;
else
bp->b_error = ENODEV;
goto bad;
}
/* Validate the request. */
if (bounds_check_with_label(bp, sc->sc_dk.dk_label) == -1)
goto done;
/* Place it in the queue of disk activities for this disk. */
bufq_queue(&sc->sc_bufq, bp);
/*
* Tell the device to get going on the transfer if it's
* not doing anything, otherwise just wait for completion
*/
scsi_xsh_add(&sc->sc_xsh);
device_unref(&sc->sc_dev);
return;
bad:
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
done:
s = splbio();
biodone(bp);
splx(s);
if (sc != NULL)
device_unref(&sc->sc_dev);
}
/*
* Close the device. Only called if we are the last occurrence of an open
* device. Convenient now but usually a pain.
*/
int
sdclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct sd_softc *sc;
int part = DISKPART(dev);
int error;
sc = sdlookup(DISKUNIT(dev));
if (sc == NULL)
return (ENXIO);
if (sc->flags & SDF_DYING) {
device_unref(&sc->sc_dev);
return (ENXIO);
}
if ((error = sdlock(sc)) != 0) {
device_unref(&sc->sc_dev);
return (error);
}
switch (fmt) {
case S_IFCHR:
sc->sc_dk.dk_copenmask &= ~(1 << part);
break;
case S_IFBLK:
sc->sc_dk.dk_bopenmask &= ~(1 << part);
break;
}
sc->sc_dk.dk_openmask = sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask;
if (sc->sc_dk.dk_openmask == 0) {
if ((sc->flags & SDF_DIRTY) != 0)
sd_flush(sc, 0);
if ((sc->sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sc->sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_NOT_READY | SCSI_SILENT);
sc->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
if (sc->sc_link->flags & SDEV_EJECTING) {
scsi_start(sc->sc_link, SSS_STOP|SSS_LOEJ, 0);
sc->sc_link->flags &= ~SDEV_EJECTING;
}
timeout_del(&sc->sc_timeout);
}
sdunlock(sc);
device_unref(&sc->sc_dev);
return 0;
}
/*
* Read/write routine for a buffer. Validates the arguments and schedules the
* transfer. Does not wait for the transfer to complete.
*/
void
wdstrategy(struct buf *bp)
{
struct wd_softc *wd;
int s;
wd = wdlookup(DISKUNIT(bp->b_dev));
if (wd == NULL) {
bp->b_error = ENXIO;
goto bad;
}
WDCDEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
DEBUG_XFERS);
/* If device invalidated (e.g. media change, door open), error. */
if ((wd->sc_flags & WDF_LOADED) == 0) {
bp->b_error = EIO;
goto bad;
}
/* Validate the request. */
if (bounds_check_with_label(bp, wd->sc_dk.dk_label) == -1)
goto done;
/* Check that the number of sectors can fit in a byte. */
if ((bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
bp->b_error = EINVAL;
goto bad;
}
/* Queue transfer on drive, activate drive and controller if idle. */
bufq_queue(&wd->sc_bufq, bp);
s = splbio();
wdstart(wd);
splx(s);
device_unref(&wd->sc_dev);
return;
bad:
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
done:
s = splbio();
biodone(bp);
splx(s);
if (wd != NULL)
device_unref(&wd->sc_dev);
}
/*
* Close the device. Only called if we are the last occurrence of an open
* device.
*/
int
cdclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct cd_softc *cd;
int part = DISKPART(dev);
int error;
cd = cdlookup(DISKUNIT(dev));
if (cd == NULL)
return ENXIO;
if ((error = cdlock(cd)) != 0) {
device_unref(&cd->sc_dev);
return error;
}
switch (fmt) {
case S_IFCHR:
cd->sc_dk.dk_copenmask &= ~(1 << part);
break;
case S_IFBLK:
cd->sc_dk.dk_bopenmask &= ~(1 << part);
break;
}
cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
if (cd->sc_dk.dk_openmask == 0) {
/* XXXX Must wait for I/O to complete! */
scsi_prevent(cd->sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY |
SCSI_SILENT);
cd->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
if (cd->sc_link->flags & SDEV_EJECTING) {
scsi_start(cd->sc_link, SSS_STOP|SSS_LOEJ, 0);
cd->sc_link->flags &= ~SDEV_EJECTING;
}
timeout_del(&cd->sc_timeout);
}
cdunlock(cd);
device_unref(&cd->sc_dev);
return 0;
}
int
rdopen(dev_t dev, int flag, int fmt, struct proc *p)
{
struct rd_softc *sc;
u_int unit, part;
int error;
unit = DISKUNIT(dev);
part = DISKPART(dev);
sc = rdlookup(unit);
if (sc == NULL)
return (ENXIO);
if ((error = disk_lock(&sc->sc_dk)) != 0)
goto unref;
if (sc->sc_dk.dk_openmask == 0) {
/* Load the partition info if not already loaded. */
if ((error = rdgetdisklabel(dev, sc, sc->sc_dk.dk_label, 0))
!= 0)
goto unlock;
}
error = disk_openpart(&sc->sc_dk, part, fmt, 1);
unlock:
disk_unlock(&sc->sc_dk);
unref:
device_unref(&sc->sc_dev);
return (error);
}
int
vldcpopen(dev_t dev, int flag, int mode, struct proc *p)
{
struct vldcp_softc *sc;
struct ldc_conn *lc;
uint64_t rx_head, rx_tail, rx_state;
int err;
sc = vldcp_lookup(dev);
if (sc == NULL)
return (ENXIO);
lc = &sc->sc_lc;
err = hv_ldc_tx_qconf(lc->lc_id,
lc->lc_txq->lq_map->dm_segs[0].ds_addr, lc->lc_txq->lq_nentries);
if (err != H_EOK)
printf("%s: hv_ldc_tx_qconf %d\n", __func__, err);
err = hv_ldc_rx_qconf(lc->lc_id,
lc->lc_rxq->lq_map->dm_segs[0].ds_addr, lc->lc_rxq->lq_nentries);
if (err != H_EOK)
printf("%s: hv_ldc_rx_qconf %d\n", __func__, err);
/* Clear a pending channel reset. */
err = hv_ldc_rx_get_state(lc->lc_id, &rx_head, &rx_tail, &rx_state);
if (err != H_EOK)
printf("%s: hv_ldc_rx_get_state %d\n", __func__, err);
device_unref(&sc->sc_dv);
return (0);
}
int
midipoll(dev_t dev, int events, struct proc *p)
{
struct midi_softc *sc;
int revents;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return POLLERR;
revents = 0;
mtx_enter(&audio_lock);
if (events & (POLLIN | POLLRDNORM)) {
if (!MIDIBUF_ISEMPTY(&sc->inbuf))
revents |= events & (POLLIN | POLLRDNORM);
}
if (events & (POLLOUT | POLLWRNORM)) {
if (!MIDIBUF_ISFULL(&sc->outbuf))
revents |= events & (POLLOUT | POLLWRNORM);
}
if (revents == 0) {
if (events & (POLLIN | POLLRDNORM))
selrecord(p, &sc->rsel);
if (events & (POLLOUT | POLLWRNORM))
selrecord(p, &sc->wsel);
}
mtx_leave(&audio_lock);
device_unref(&sc->dev);
return (revents);
}
daddr_t
wdsize(dev_t dev)
{
struct wd_softc *wd;
struct disklabel *lp;
int part, omask;
daddr_t size;
WDCDEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
wd = wdlookup(DISKUNIT(dev));
if (wd == NULL)
return (-1);
part = DISKPART(dev);
omask = wd->sc_dk.dk_openmask & (1 << part);
if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0) {
size = -1;
goto exit;
}
lp = wd->sc_dk.dk_label;
size = DL_SECTOBLK(lp, DL_GETPSIZE(&lp->d_partitions[part]));
if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
size = -1;
exit:
device_unref(&wd->sc_dev);
return (size);
}
int
midiopen(dev_t dev, int flags, int mode, struct proc *p)
{
struct midi_softc *sc;
int error;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return ENXIO;
error = 0;
if (sc->flags) {
error = EBUSY;
goto done;
}
MIDIBUF_INIT(&sc->inbuf);
MIDIBUF_INIT(&sc->outbuf);
sc->isbusy = 0;
sc->rchan = sc->wchan = 0;
sc->async = 0;
sc->flags = flags;
error = sc->hw_if->open(sc->hw_hdl, flags, midi_iintr, midi_ointr, sc);
if (error)
sc->flags = 0;
done:
device_unref(&sc->dev);
return error;
}
int
midiioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
{
struct midi_softc *sc;
int error;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return ENXIO;
error = 0;
switch(cmd) {
case FIONBIO:
/* All handled in the upper FS layer */
break;
case FIOASYNC:
if (*(int *)addr) {
if (sc->async) {
error = EBUSY;
goto done;
}
sc->async = p;
} else
sc->async = 0;
break;
default:
error = ENOTTY;
}
done:
device_unref(&sc->dev);
return error;
}
int
midikqfilter(dev_t dev, struct knote *kn)
{
struct midi_softc *sc;
struct klist *klist;
int error;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return ENXIO;
error = 0;
switch (kn->kn_filter) {
case EVFILT_READ:
klist = &sc->rsel.si_note;
kn->kn_fop = &midiread_filtops;
break;
case EVFILT_WRITE:
klist = &sc->wsel.si_note;
kn->kn_fop = &midiwrite_filtops;
break;
default:
error = EINVAL;
goto done;
}
kn->kn_hook = (void *)sc;
mtx_enter(&audio_lock);
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
mtx_leave(&audio_lock);
done:
device_unref(&sc->dev);
return error;
}
void
cdminphys(struct buf *bp)
{
struct cd_softc *cd;
long max;
cd = cdlookup(DISKUNIT(bp->b_dev));
if (cd == NULL)
return;
/*
* If the device is ancient, we want to make sure that
* the transfer fits into a 6-byte cdb.
*
* XXX Note that the SCSI-I spec says that 256-block transfers
* are allowed in a 6-byte read/write, and are specified
* by setting the "length" to 0. However, we're conservative
* here, allowing only 255-block transfers in case an
* ancient device gets confused by length == 0. A length of 0
* in a 10-byte read/write actually means 0 blocks.
*/
if (cd->flags & CDF_ANCIENT) {
max = cd->sc_dk.dk_label->d_secsize * 0xff;
if (bp->b_bcount > max)
bp->b_bcount = max;
}
(*cd->sc_link->adapter->scsi_minphys)(bp);
device_unref(&cd->sc_dev);
}
int
wdclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct wd_softc *wd;
int part = DISKPART(dev);
wd = wdlookup(DISKUNIT(dev));
if (wd == NULL)
return ENXIO;
WDCDEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
disk_lock_nointr(&wd->sc_dk);
disk_closepart(&wd->sc_dk, part, fmt);
if (wd->sc_dk.dk_openmask == 0) {
wd_flushcache(wd, 0);
/* XXXX Must wait for I/O to complete! */
}
disk_unlock(&wd->sc_dk);
device_unref(&wd->sc_dev);
return (0);
}
int
rdioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p)
{
struct rd_softc *sc;
struct disklabel *lp;
int error = 0;
sc = rdlookup(DISKUNIT(dev));
if (sc == NULL)
return (ENXIO);
switch (cmd) {
case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
rdgetdisklabel(dev, sc, lp, 0);
bcopy(lp, sc->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
goto done;
case DIOCGPDINFO:
rdgetdisklabel(dev, sc, (struct disklabel *)data, 1);
goto done;
case DIOCGDINFO:
*(struct disklabel *)data = *(sc->sc_dk.dk_label);
goto done;
case DIOCGPART:
((struct partinfo *)data)->disklab = sc->sc_dk.dk_label;
((struct partinfo *)data)->part =
&sc->sc_dk.dk_label->d_partitions[DISKPART(dev)];
goto done;
case DIOCWDINFO:
case DIOCSDINFO:
if ((fflag & FWRITE) == 0) {
error = EBADF;
goto done;
}
if ((error = disk_lock(&sc->sc_dk)) != 0)
goto done;
error = setdisklabel(sc->sc_dk.dk_label,
(struct disklabel *)data, sc->sc_dk.dk_openmask);
if (error == 0) {
if (cmd == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
rdstrategy, sc->sc_dk.dk_label);
}
disk_unlock(&sc->sc_dk);
goto done;
}
done:
device_unref(&sc->sc_dev);
return (error);
}
int
midiread(dev_t dev, struct uio *uio, int ioflag)
{
struct midi_softc *sc;
struct midi_buffer *mb;
size_t count;
int error;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return ENXIO;
if (!(sc->flags & FREAD)) {
error = ENXIO;
goto done;
}
mb = &sc->inbuf;
/* if there is no data then sleep (unless IO_NDELAY flag is set) */
error = 0;
mtx_enter(&audio_lock);
while (MIDIBUF_ISEMPTY(mb)) {
if (ioflag & IO_NDELAY) {
mtx_leave(&audio_lock);
error = EWOULDBLOCK;
goto done;
}
sc->rchan = 1;
error = msleep(&sc->rchan, &audio_lock, PWAIT | PCATCH, "mid_rd", 0);
if (!(sc->dev.dv_flags & DVF_ACTIVE))
error = EIO;
if (error) {
mtx_leave(&audio_lock);
goto done;
}
}
/* at this stage, there is at least 1 byte */
while (uio->uio_resid > 0 && mb->used > 0) {
count = MIDIBUF_SIZE - mb->start;
if (count > mb->used)
count = mb->used;
if (count > uio->uio_resid)
count = uio->uio_resid;
mtx_leave(&audio_lock);
error = uiomove(mb->data + mb->start, count, uio);
if (error)
goto done;
mtx_enter(&audio_lock);
MIDIBUF_REMOVE(mb, count);
}
mtx_leave(&audio_lock);
done:
device_unref(&sc->dev);
return error;
}
/*
* Close the device. Only called if we are the last occurrence of an open
* device. Convenient now but usually a pain.
*/
int
sdclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct sd_softc *sc;
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);
}
disk_lock_nointr(&sc->sc_dk);
disk_closepart(&sc->sc_dk, part, fmt);
if (sc->sc_dk.dk_openmask == 0) {
if ((sc->flags & SDF_DIRTY) != 0)
sd_flush(sc, 0);
if ((sc->sc_link->flags & SDEV_REMOVABLE) != 0)
scsi_prevent(sc->sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_NOT_READY | SCSI_SILENT);
sc->sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
if (sc->sc_link->flags & SDEV_EJECTING) {
scsi_start(sc->sc_link, SSS_STOP|SSS_LOEJ, 0);
sc->sc_link->flags &= ~SDEV_EJECTING;
}
timeout_del(&sc->sc_timeout);
scsi_xsh_del(&sc->sc_xsh);
}
disk_unlock(&sc->sc_dk);
device_unref(&sc->sc_dev);
return 0;
}
void
rdstrategy(struct buf *bp)
{
struct rd_softc *sc;
struct partition *p;
size_t off, xfer;
caddr_t addr;
int s;
sc = rdlookup(DISKUNIT(bp->b_dev));
if (sc == NULL) {
bp->b_error = ENXIO;
goto bad;
}
/* Validate the request. */
if (bounds_check_with_label(bp, sc->sc_dk.dk_label) == -1)
goto done;
/* Do the transfer. */
/* XXX: Worry about overflow when computing off? */
p = &sc->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)];
off = DL_GETPOFFSET(p) * sc->sc_dk.dk_label->d_secsize +
(u_int64_t)bp->b_blkno * DEV_BSIZE;
if (off > rd_root_size)
off = rd_root_size;
xfer = bp->b_bcount;
if (xfer > rd_root_size - off)
xfer = rd_root_size - off;
addr = rd_root_image + off;
if (bp->b_flags & B_READ)
memcpy(bp->b_data, addr, xfer);
else
memcpy(addr, bp->b_data, xfer);
bp->b_resid = bp->b_bcount - xfer;
goto done;
bad:
bp->b_flags |= B_ERROR;
bp->b_resid = bp->b_bcount;
done:
s = splbio();
biodone(bp);
splx(s);
if (sc != NULL)
device_unref(&sc->sc_dev);
}
int
vldcpclose(dev_t dev, int flag, int mode, struct proc *p)
{
struct vldcp_softc *sc;
sc = vldcp_lookup(dev);
if (sc == NULL)
return (ENXIO);
cbus_intr_setenabled(sc->sc_tx_sysino, INTR_DISABLED);
cbus_intr_setenabled(sc->sc_rx_sysino, INTR_DISABLED);
hv_ldc_tx_qconf(sc->sc_lc.lc_id, 0, 0);
hv_ldc_rx_qconf(sc->sc_lc.lc_id, 0, 0);
device_unref(&sc->sc_dv);
return (0);
}
int
midiclose(dev_t dev, int fflag, int devtype, struct proc *p)
{
struct midi_softc *sc;
struct midi_buffer *mb;
int error;
sc = (struct midi_softc *)device_lookup(&midi_cd, minor(dev));
if (sc == NULL)
return ENXIO;
/* start draining output buffer */
error = 0;
mb = &sc->outbuf;
mtx_enter(&audio_lock);
if (!MIDIBUF_ISEMPTY(mb))
midi_out_start(sc);
while (sc->isbusy) {
sc->wchan = 1;
error = msleep(&sc->wchan, &audio_lock,
PWAIT, "mid_dr", 5 * hz);
if (!(sc->dev.dv_flags & DVF_ACTIVE))
error = EIO;
if (error)
break;
}
mtx_leave(&audio_lock);
/*
* some hw_if->close() reset immediately the midi uart
* which flushes the internal buffer of the uart device,
* so we may lose some (important) data. To avoid this,
* sleep 20ms (around 64 bytes) to give the time to the
* uart to drain its internal buffers.
*/
tsleep(&sc->wchan, PWAIT, "mid_cl", hz * MIDI_MAXWRITE / MIDI_RATE);
sc->hw_if->close(sc->hw_hdl);
sc->flags = 0;
device_unref(&sc->dev);
return 0;
}
int
rdclose(dev_t dev, int flag, int fmt, struct proc *p)
{
struct rd_softc *sc;
u_int unit, part;
unit = DISKUNIT(dev);
part = DISKPART(dev);
sc = rdlookup(unit);
if (sc == NULL)
return (ENXIO);
disk_lock_nointr(&sc->sc_dk);
disk_closepart(&sc->sc_dk, part, fmt);
disk_unlock(&sc->sc_dk);
device_unref(&sc->sc_dev);
return (0);
}
daddr_t
sdsize(dev_t dev)
{
struct disklabel *lp;
struct sd_softc *sc;
int part, omask;
daddr_t size;
sc = sdlookup(DISKUNIT(dev));
if (sc == NULL)
return -1;
if (sc->flags & SDF_DYING) {
size = -1;
goto exit;
}
part = DISKPART(dev);
omask = sc->sc_dk.dk_openmask & (1 << part);
if (omask == 0 && sdopen(dev, 0, S_IFBLK, NULL) != 0) {
size = -1;
goto exit;
}
lp = sc->sc_dk.dk_label;
if ((sc->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
size = -1;
else if (lp->d_partitions[part].p_fstype != FS_SWAP)
size = -1;
else
size = DL_SECTOBLK(lp, DL_GETPSIZE(&lp->d_partitions[part]));
if (omask == 0 && sdclose(dev, 0, S_IFBLK, NULL) != 0)
size = -1;
exit:
device_unref(&sc->sc_dev);
return size;
}
/*
* Actually translate the requested transfer into one the physical driver can
* understand. The transfer is described by a buf and will include only one
* physical transfer.
*/
void
cdstrategy(struct buf *bp)
{
struct cd_softc *cd;
int s;
if ((cd = cdlookup(DISKUNIT(bp->b_dev))) == NULL) {
bp->b_error = ENXIO;
goto bad;
}
SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdstrategy: %ld bytes @ blk %d\n",
bp->b_bcount, bp->b_blkno));
/*
* If the device has been made invalid, error out
* maybe the media changed, or no media loaded
*/
if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
bp->b_error = EIO;
goto bad;
}
/*
* The transfer must be a whole number of blocks.
*/
if ((bp->b_bcount % cd->sc_dk.dk_label->d_secsize) != 0) {
bp->b_error = EINVAL;
goto bad;
}
/*
* If it's a null transfer, return immediately
*/
if (bp->b_bcount == 0)
goto done;
/*
* Do bounds checking, adjust transfer. if error, process.
* If end of partition, just return.
*/
if (bounds_check_with_label(bp, cd->sc_dk.dk_label,
(cd->flags & (CDF_WLABEL|CDF_LABELLING)) != 0) <= 0)
goto done;
s = splbio();
/*
* Place it in the queue of disk activities for this disk
*/
disksort(&cd->buf_queue, bp);
/*
* Tell the device to get going on the transfer if it's
* not doing anything, otherwise just wait for completion
*/
cdstart(cd);
device_unref(&cd->sc_dev);
splx(s);
return;
bad:
bp->b_flags |= B_ERROR;
done:
/*
* Correctly set the buf to indicate a completed xfer
*/
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
if (cd != NULL)
device_unref(&cd->sc_dev);
}
/*
* Open the device. Make sure the partition info is as up-to-date as can be.
*/
int
cdopen(dev_t dev, int flag, int fmt, struct proc *p)
{
struct scsi_link *sc_link;
struct cd_softc *cd;
int error = 0, part, rawopen, unit;
unit = DISKUNIT(dev);
part = DISKPART(dev);
rawopen = (part == RAW_PART) && (fmt == S_IFCHR);
cd = cdlookup(unit);
if (cd == NULL)
return (ENXIO);
sc_link = cd->sc_link;
SC_DEBUG(sc_link, SDEV_DB1,
("cdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
cd_cd.cd_ndevs, part));
if ((error = cdlock(cd)) != 0) {
device_unref(&cd->sc_dev);
return (error);
}
if (cd->sc_dk.dk_openmask != 0) {
/*
* If any partition is open, but the disk has been invalidated,
* disallow further opens.
*/
if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
if (rawopen)
goto out;
error = EIO;
goto bad;
}
} else {
/*
* Check that it is still responding and ok. Drive can be in
* progress of loading media so use increased retries number
* and don't ignore NOT_READY.
*/
/* Use cd_interpret_sense() now. */
sc_link->flags |= SDEV_OPEN;
error = scsi_test_unit_ready(sc_link, TEST_READY_RETRIES,
(rawopen ? SCSI_SILENT : 0) | SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE);
/* Start the cd spinning if necessary. */
if (error == EIO)
error = scsi_start(sc_link, SSS_START,
SCSI_IGNORE_ILLEGAL_REQUEST |
SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT);
if (error) {
if (rawopen) {
error = 0;
goto out;
} else
goto bad;
}
/* Lock the cd in. */
error = scsi_prevent(sc_link, PR_PREVENT,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE |
SCSI_SILENT);
if (error)
goto bad;
/* Load the physical device parameters. */
sc_link->flags |= SDEV_MEDIA_LOADED;
if (cd_get_parms(cd, (rawopen ? SCSI_SILENT : 0) |
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE)) {
sc_link->flags &= ~SDEV_MEDIA_LOADED;
error = ENXIO;
goto bad;
}
SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded\n"));
/* Fabricate a disk label. */
cdgetdisklabel(dev, cd, cd->sc_dk.dk_label, 0);
SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel fabricated\n"));
}
/* Check that the partition exists. */
if (part != RAW_PART && (part >= cd->sc_dk.dk_label->d_npartitions ||
cd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
error = ENXIO;
goto bad;
}
out: /* Insure only one open at a time. */
switch (fmt) {
case S_IFCHR:
cd->sc_dk.dk_copenmask |= (1 << part);
break;
case S_IFBLK:
cd->sc_dk.dk_bopenmask |= (1 << part);
break;
}
cd->sc_dk.dk_openmask = cd->sc_dk.dk_copenmask | cd->sc_dk.dk_bopenmask;
sc_link->flags |= SDEV_OPEN;
SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
/* It's OK to fall through because dk_openmask is now non-zero. */
bad:
if (cd->sc_dk.dk_openmask == 0) {
scsi_prevent(sc_link, PR_ALLOW,
SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE |
SCSI_SILENT);
sc_link->flags &= ~(SDEV_OPEN | SDEV_MEDIA_LOADED);
}
cdunlock(cd);
device_unref(&cd->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 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);
}
/*
* Actually translate the requested transfer into one the physical driver
* can understand. The transfer is described by a buf and will include
* only one physical transfer.
*/
void
sdstrategy(struct buf *bp)
{
struct sd_softc *sc;
int s;
sc = sdlookup(DISKUNIT(bp->b_dev));
if (sc == NULL) {
bp->b_error = ENXIO;
goto bad;
}
if (sc->flags & SDF_DYING) {
bp->b_error = ENXIO;
goto bad;
}
SC_DEBUG(sc->sc_link, SDEV_DB2, ("sdstrategy: %ld bytes @ blk %d\n",
bp->b_bcount, bp->b_blkno));
/*
* If the device has been made invalid, error out
*/
if ((sc->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
if (sc->sc_link->flags & SDEV_OPEN)
bp->b_error = EIO;
else
bp->b_error = ENODEV;
goto bad;
}
/*
* If it's a null transfer, return immediately
*/
if (bp->b_bcount == 0)
goto done;
/*
* The transfer must be a whole number of sectors.
*/
if ((bp->b_bcount % sc->sc_dk.dk_label->d_secsize) != 0) {
bp->b_error = EINVAL;
goto bad;
}
/*
* Do bounds checking, adjust transfer. if error, process.
* If end of partition, just return.
*/
if (bounds_check_with_label(bp, sc->sc_dk.dk_label,
(sc->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
goto done;
/*
* Place it in the queue of disk activities for this disk
*/
mtx_enter(&sc->sc_buf_mtx);
disksort(&sc->sc_buf_queue, bp);
mtx_leave(&sc->sc_buf_mtx);
/*
* Tell the device to get going on the transfer if it's
* not doing anything, otherwise just wait for completion
*/
sdstart(sc);
device_unref(&sc->sc_dev);
return;
bad:
bp->b_flags |= B_ERROR;
done:
/*
* Correctly set the buf to indicate a completed xfer
*/
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
if (sc != NULL)
device_unref(&sc->sc_dev);
}
int
wdopen(dev_t dev, int flag, int fmt, struct proc *p)
{
struct wd_softc *wd;
struct channel_softc *chnl;
int unit, part;
int error;
WDCDEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
unit = DISKUNIT(dev);
wd = wdlookup(unit);
if (wd == NULL)
return ENXIO;
chnl = (struct channel_softc *)(wd->drvp->chnl_softc);
if (chnl->dying)
return (ENXIO);
/*
* If this is the first open of this device, add a reference
* to the adapter.
*/
if ((error = disk_lock(&wd->sc_dk)) != 0)
goto bad4;
if (wd->sc_dk.dk_openmask != 0) {
/*
* If any partition is open, but the disk has been invalidated,
* disallow further opens.
*/
if ((wd->sc_flags & WDF_LOADED) == 0) {
error = EIO;
goto bad3;
}
} else {
if ((wd->sc_flags & WDF_LOADED) == 0) {
wd->sc_flags |= WDF_LOADED;
/* Load the physical device parameters. */
wd_get_params(wd, AT_WAIT, &wd->sc_params);
/* Load the partition info if not already loaded. */
if (wdgetdisklabel(dev, wd,
wd->sc_dk.dk_label, 0) == EIO) {
error = EIO;
goto bad;
}
}
}
part = DISKPART(dev);
if ((error = disk_openpart(&wd->sc_dk, part, fmt, 1)) != 0)
goto bad;
disk_unlock(&wd->sc_dk);
device_unref(&wd->sc_dev);
return 0;
bad:
if (wd->sc_dk.dk_openmask == 0) {
}
bad3:
disk_unlock(&wd->sc_dk);
bad4:
device_unref(&wd->sc_dev);
return error;
}
/*
* Perform special action on behalf of the user.
* Knows about the internals of this device
*/
int
cdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
{
struct cd_softc *cd;
struct disklabel *lp;
int part = DISKPART(dev);
int error = 0;
cd = cdlookup(DISKUNIT(dev));
if (cd == NULL)
return ENXIO;
SC_DEBUG(cd->sc_link, SDEV_DB2, ("cdioctl 0x%lx\n", cmd));
/*
* If the device is not valid.. abandon ship
*/
if ((cd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
switch (cmd) {
case DIOCWLABEL:
case DIOCLOCK:
case DIOCEJECT:
case SCIOCIDENTIFY:
case SCIOCCOMMAND:
case SCIOCDEBUG:
case CDIOCLOADUNLOAD:
case SCIOCRESET:
case CDIOCGETVOL:
case CDIOCSETVOL:
case CDIOCSETMONO:
case CDIOCSETSTEREO:
case CDIOCSETMUTE:
case CDIOCSETLEFT:
case CDIOCSETRIGHT:
case CDIOCCLOSE:
case CDIOCEJECT:
case CDIOCALLOW:
case CDIOCPREVENT:
case CDIOCSETDEBUG:
case CDIOCCLRDEBUG:
case CDIOCRESET:
case DVD_AUTH:
case DVD_READ_STRUCT:
case MTIOCTOP:
if (part == RAW_PART)
break;
/* FALLTHROUGH */
default:
if ((cd->sc_link->flags & SDEV_OPEN) == 0)
error = ENODEV;
else
error = EIO;
goto exit;
}
}
switch (cmd) {
case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
cdgetdisklabel(dev, cd, lp, 0);
bcopy(lp, cd->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
break;
case DIOCGDINFO:
case DIOCGPDINFO:
*(struct disklabel *)addr = *(cd->sc_dk.dk_label);
break;
case DIOCGPART:
((struct partinfo *)addr)->disklab = cd->sc_dk.dk_label;
((struct partinfo *)addr)->part =
&cd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
break;
case DIOCWDINFO:
case DIOCSDINFO:
if ((flag & FWRITE) == 0) {
error = EBADF;
break;
}
if ((error = cdlock(cd)) != 0)
break;
cd->flags |= CDF_LABELLING;
error = setdisklabel(cd->sc_dk.dk_label,
(struct disklabel *)addr, /*cd->sc_dk.dk_openmask : */0);
if (error == 0) {
}
cd->flags &= ~CDF_LABELLING;
cdunlock(cd);
break;
case DIOCWLABEL:
error = EBADF;
break;
case CDIOCPLAYTRACKS: {
struct ioc_play_track *args = (struct ioc_play_track *)addr;
if ((error = cd_set_pa_immed(cd, 0)) != 0)
break;
error = cd_play_tracks(cd, args->start_track,
args->start_index, args->end_track, args->end_index);
break;
}
case CDIOCPLAYMSF: {
struct ioc_play_msf *args = (struct ioc_play_msf *)addr;
if ((error = cd_set_pa_immed(cd, 0)) != 0)
break;
error = cd_play_msf(cd, args->start_m, args->start_s,
args->start_f, args->end_m, args->end_s, args->end_f);
break;
}
case CDIOCPLAYBLOCKS: {
struct ioc_play_blocks *args = (struct ioc_play_blocks *)addr;
if ((error = cd_set_pa_immed(cd, 0)) != 0)
break;
error = cd_play(cd, args->blk, args->len);
break;
}
case CDIOCREADSUBCHANNEL: {
struct ioc_read_subchannel *args
= (struct ioc_read_subchannel *)addr;
struct cd_sub_channel_info data;
int len = args->data_len;
if (len > sizeof(data) ||
len < sizeof(struct cd_sub_channel_header)) {
error = EINVAL;
break;
}
error = cd_read_subchannel(cd, args->address_format,
args->data_format, args->track,
&data, len);
if (error)
break;
len = min(len, _2btol(data.header.data_len) +
sizeof(struct cd_sub_channel_header));
error = copyout(&data, args->data, len);
break;
}
case CDIOREADTOCHEADER: {
struct ioc_toc_header th;
if ((error = cd_read_toc(cd, 0, 0, &th, sizeof(th), 0)) != 0)
break;
if (cd->sc_link->quirks & ADEV_LITTLETOC)
th.len = letoh16(th.len);
else
th.len = betoh16(th.len);
bcopy(&th, addr, sizeof(th));
break;
}
case CDIOREADTOCENTRYS: {
struct cd_toc *toc;
struct ioc_read_toc_entry *te =
(struct ioc_read_toc_entry *)addr;
struct ioc_toc_header *th;
struct cd_toc_entry *cte;
int len = te->data_len;
int ntracks;
toc = malloc(sizeof(*toc), M_TEMP, M_WAITOK | M_ZERO);
th = &toc->header;
if (len > sizeof(toc->entries) ||
len < sizeof(struct cd_toc_entry)) {
free(toc, M_TEMP);
error = EINVAL;
break;
}
error = cd_read_toc(cd, te->address_format, te->starting_track,
toc, len + sizeof(struct ioc_toc_header), 0);
if (error) {
free(toc, M_TEMP);
break;
}
if (te->address_format == CD_LBA_FORMAT)
for (ntracks =
th->ending_track - th->starting_track + 1;
ntracks >= 0; ntracks--) {
cte = &toc->entries[ntracks];
cte->addr_type = CD_LBA_FORMAT;
if (cd->sc_link->quirks & ADEV_LITTLETOC) {
#if BYTE_ORDER == BIG_ENDIAN
swap16_multi((u_int16_t *)&cte->addr,
sizeof(cte->addr) / 2);
#endif
} else
cte->addr.lba = betoh32(cte->addr.lba);
}
if (cd->sc_link->quirks & ADEV_LITTLETOC) {
th->len = letoh16(th->len);
} else
th->len = betoh16(th->len);
len = min(len, th->len - (sizeof(th->starting_track) +
sizeof(th->ending_track)));
error = copyout(toc->entries, te->data, len);
free(toc, M_TEMP);
break;
}
case CDIOREADMSADDR: {
struct cd_toc *toc;
int sessno = *(int *)addr;
struct cd_toc_entry *cte;
if (sessno != 0) {
error = EINVAL;
break;
}
toc = malloc(sizeof(*toc), M_TEMP, M_WAITOK | M_ZERO);
error = cd_read_toc(cd, 0, 0, toc,
sizeof(struct ioc_toc_header) + sizeof(struct cd_toc_entry),
0x40 /* control word for "get MS info" */);
if (error) {
free(toc, M_TEMP);
break;
}
cte = &toc->entries[0];
if (cd->sc_link->quirks & ADEV_LITTLETOC) {
#if BYTE_ORDER == BIG_ENDIAN
swap16_multi((u_int16_t *)&cte->addr,
sizeof(cte->addr) / 2);
#endif
} else
cte->addr.lba = betoh32(cte->addr.lba);
if (cd->sc_link->quirks & ADEV_LITTLETOC)
toc->header.len = letoh16(toc->header.len);
else
toc->header.len = betoh16(toc->header.len);
*(int *)addr = (toc->header.len >= 10 && cte->track > 1) ?
cte->addr.lba : 0;
free(toc, M_TEMP);
break;
}
case CDIOCSETPATCH: {
struct ioc_patch *arg = (struct ioc_patch *)addr;
error = cd_setchan(cd, arg->patch[0], arg->patch[1],
arg->patch[2], arg->patch[3], 0);
break;
}
case CDIOCGETVOL: {
struct ioc_vol *arg = (struct ioc_vol *)addr;
error = cd_getvol(cd, arg, 0);
break;
}
case CDIOCSETVOL: {
struct ioc_vol *arg = (struct ioc_vol *)addr;
error = cd_setvol(cd, arg, 0);
break;
}
case CDIOCSETMONO:
error = cd_setchan(cd, BOTH_CHANNEL, BOTH_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
break;
case CDIOCSETSTEREO:
error = cd_setchan(cd, LEFT_CHANNEL, RIGHT_CHANNEL,
MUTE_CHANNEL, MUTE_CHANNEL, 0);
break;
case CDIOCSETMUTE:
error = cd_setchan(cd, MUTE_CHANNEL, MUTE_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
break;
case CDIOCSETLEFT:
error = cd_setchan(cd, LEFT_CHANNEL, LEFT_CHANNEL, MUTE_CHANNEL,
MUTE_CHANNEL, 0);
break;
case CDIOCSETRIGHT:
error = cd_setchan(cd, RIGHT_CHANNEL, RIGHT_CHANNEL,
MUTE_CHANNEL, MUTE_CHANNEL, 0);
break;
case CDIOCRESUME:
error = cd_pause(cd, 1);
break;
case CDIOCPAUSE:
error = cd_pause(cd, 0);
break;
case CDIOCSTART:
error = scsi_start(cd->sc_link, SSS_START, 0);
break;
case CDIOCSTOP:
error = scsi_start(cd->sc_link, SSS_STOP, 0);
break;
close_tray:
case CDIOCCLOSE:
error = scsi_start(cd->sc_link, SSS_START|SSS_LOEJ,
SCSI_IGNORE_NOT_READY | SCSI_IGNORE_MEDIA_CHANGE);
break;
case MTIOCTOP:
if (((struct mtop *)addr)->mt_op == MTRETEN)
goto close_tray;
if (((struct mtop *)addr)->mt_op != MTOFFL) {
error = EIO;
break;
}
/* FALLTHROUGH */
case CDIOCEJECT: /* FALLTHROUGH */
case DIOCEJECT:
cd->sc_link->flags |= SDEV_EJECTING;
break;
case CDIOCALLOW:
error = scsi_prevent(cd->sc_link, PR_ALLOW, 0);
break;
case CDIOCPREVENT:
error = scsi_prevent(cd->sc_link, PR_PREVENT, 0);
break;
case DIOCLOCK:
error = scsi_prevent(cd->sc_link,
(*(int *)addr) ? PR_PREVENT : PR_ALLOW, 0);
break;
case CDIOCSETDEBUG:
cd->sc_link->flags |= (SDEV_DB1 | SDEV_DB2);
break;
case CDIOCCLRDEBUG:
cd->sc_link->flags &= ~(SDEV_DB1 | SDEV_DB2);
break;
case CDIOCRESET:
case SCIOCRESET:
error = cd_reset(cd);
break;
case CDIOCLOADUNLOAD: {
struct ioc_load_unload *args = (struct ioc_load_unload *)addr;
error = cd_load_unload(cd, args->options, args->slot);
break;
}
case DVD_AUTH:
error = dvd_auth(cd, (union dvd_authinfo *)addr);
break;
case DVD_READ_STRUCT:
error = dvd_read_struct(cd, (union dvd_struct *)addr);
break;
default:
if (DISKPART(dev) != RAW_PART) {
error = ENOTTY;
break;
}
error = scsi_do_ioctl(cd->sc_link, dev, cmd, addr, flag, p);
break;
}
exit:
device_unref(&cd->sc_dev);
return (error);
}
int
wdioctl(dev_t dev, u_long xfer, caddr_t addr, int flag, struct proc *p)
{
struct wd_softc *wd;
struct disklabel *lp;
int error = 0;
WDCDEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
wd = wdlookup(DISKUNIT(dev));
if (wd == NULL)
return ENXIO;
if ((wd->sc_flags & WDF_LOADED) == 0) {
error = EIO;
goto exit;
}
switch (xfer) {
case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
wdgetdisklabel(dev, wd, lp, 0);
bcopy(lp, wd->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP, 0);
goto exit;
case DIOCGPDINFO:
wdgetdisklabel(dev, wd, (struct disklabel *)addr, 1);
goto exit;
case DIOCGDINFO:
*(struct disklabel *)addr = *(wd->sc_dk.dk_label);
goto exit;
case DIOCGPART:
((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
((struct partinfo *)addr)->part =
&wd->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(&wd->sc_dk)) != 0)
goto exit;
error = setdisklabel(wd->sc_dk.dk_label,
(struct disklabel *)addr, wd->sc_dk.dk_openmask);
if (error == 0) {
if (wd->drvp->state > RECAL)
wd->drvp->drive_flags |= DRIVE_RESET;
if (xfer == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
wdstrategy, wd->sc_dk.dk_label);
}
disk_unlock(&wd->sc_dk);
goto exit;
#ifdef notyet
case DIOCWFORMAT:
if ((flag & FWRITE) == 0)
return EBADF;
{
struct format_op *fop;
struct iovec aiov;
struct uio auio;
fop = (struct format_op *)addr;
aiov.iov_base = fop->df_buf;
aiov.iov_len = fop->df_count;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_resid = fop->df_count;
auio.uio_segflg = 0;
auio.uio_offset =
fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
auio.uio_procp = p;
error = physio(wdformat, dev, B_WRITE, minphys, &auio);
fop->df_count -= auio.uio_resid;
fop->df_reg[0] = wdc->sc_status;
fop->df_reg[1] = wdc->sc_error;
goto exit;
}
#endif
default:
error = wdc_ioctl(wd->drvp, xfer, addr, flag, p);
goto exit;
}
#ifdef DIAGNOSTIC
panic("wdioctl: impossible");
#endif
exit:
device_unref(&wd->sc_dev);
return (error);
}