static void
mcdstrategy(struct bio *bp)
{
struct mcd_softc *sc;
sc = (struct mcd_softc *)bp->bio_dev->si_drv1;
/* if device invalidated (e.g. media change, door open), error */
MCD_LOCK(sc);
if (!(sc->data.flags & MCDVALID)) {
device_printf(sc->dev, "media changed\n");
bp->bio_error = EIO;
goto bad;
}
/* read only */
if (!(bp->bio_cmd == BIO_READ)) {
bp->bio_error = EROFS;
goto bad;
}
/* no data to read */
if (bp->bio_bcount == 0)
goto done;
if (!(sc->data.flags & MCDTOC)) {
bp->bio_error = EIO;
goto bad;
}
bp->bio_resid = 0;
/* queue it */
bioq_disksort(&sc->data.head, bp);
/* now check whether we can perform processing */
mcd_start(sc);
MCD_UNLOCK(sc);
return;
bad:
bp->bio_flags |= BIO_ERROR;
done:
MCD_UNLOCK(sc);
bp->bio_resid = bp->bio_bcount;
biodone(bp);
return;
}
static void
mcd_doread(struct mcd_softc *sc, int state, struct mcd_mbx *mbxin)
{
struct mcd_mbx *mbx;
struct bio *bp;
int rm, i, k;
struct mcd_read2 rbuf;
int blknum;
caddr_t addr;
mbx = (state!=MCD_S_BEGIN) ? sc->ch_mbxsave : mbxin;
bp = mbx->bp;
loop:
switch (state) {
case MCD_S_BEGIN:
mbx = sc->ch_mbxsave = mbxin;
case MCD_S_BEGIN1:
retry_status:
/* get status */
MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDGETSTAT);
mbx->count = RDELAY_WAITSTAT;
sc->ch_state = MCD_S_WAITSTAT;
sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
return;
case MCD_S_WAITSTAT:
sc->ch_state = MCD_S_WAITSTAT;
untimeout(mcd_timeout,(caddr_t)sc, sc->ch);
if (mbx->count-- >= 0) {
if (MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
sc->ch_state = MCD_S_WAITSTAT;
timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
return;
}
sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
if (sc->data.status & MCD_ST_CMDCHECK)
goto retry_status;
if (mcd_setflags(sc) < 0)
goto changed;
MCD_TRACE("got WAITSTAT delay=%d\n",
RDELAY_WAITSTAT-mbx->count);
/* reject, if audio active */
if (sc->data.status & MCDAUDIOBSY) {
device_printf(sc->dev, "audio is active\n");
goto readerr;
}
retry_mode:
/* to check for raw/cooked mode */
if (sc->data.flags & MCDREADRAW) {
rm = MCD_MD_RAW;
mbx->sz = MCDRBLK;
} else {
rm = MCD_MD_COOKED;
mbx->sz = sc->data.blksize;
}
if (rm == sc->data.curr_mode)
goto modedone;
mbx->count = RDELAY_WAITMODE;
sc->data.curr_mode = MCD_MD_UNKNOWN;
mbx->mode = rm;
MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDSETMODE);
MCD_WRITE(sc, MCD_REG_COMMAND, rm);
sc->ch_state = MCD_S_WAITMODE;
sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
return;
} else {
device_printf(sc->dev, "timeout getstatus\n");
goto readerr;
}
case MCD_S_WAITMODE:
sc->ch_state = MCD_S_WAITMODE;
untimeout(mcd_timeout, (caddr_t)sc, sc->ch);
if (mbx->count-- < 0) {
device_printf(sc->dev, "timeout set mode\n");
goto readerr;
}
if (MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
sc->ch_state = MCD_S_WAITMODE;
sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100);
return;
}
sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
if (sc->data.status & MCD_ST_CMDCHECK) {
sc->data.curr_mode = MCD_MD_UNKNOWN;
goto retry_mode;
}
if (mcd_setflags(sc) < 0)
goto changed;
sc->data.curr_mode = mbx->mode;
MCD_TRACE("got WAITMODE delay=%d\n",
RDELAY_WAITMODE-mbx->count);
modedone:
/* for first block */
mbx->nblk = (bp->bio_bcount + (mbx->sz-1)) / mbx->sz;
mbx->skip = 0;
nextblock:
blknum = (bp->bio_blkno / (mbx->sz/DEV_BSIZE))
+ mbx->skip/mbx->sz;
MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
blknum, bp);
/* build parameter block */
hsg2msf(blknum,rbuf.start_msf);
retry_read:
/* send the read command */
critical_enter();
MCD_WRITE(sc, MCD_REG_COMMAND, sc->data.read_command);
MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[0]);
MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[1]);
MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[2]);
MCD_WRITE(sc, MCD_REG_COMMAND, 0);
MCD_WRITE(sc, MCD_REG_COMMAND, 0);
MCD_WRITE(sc, MCD_REG_COMMAND, 1);
critical_exit();
/* Spin briefly (<= 2ms) to avoid missing next block */
for (i = 0; i < 20; i++) {
k = MCD_READ(sc, MCD_FLAGS);
if (!(k & MFL_DATA_NOT_AVAIL))
goto got_it;
DELAY(100);
}
mbx->count = RDELAY_WAITREAD;
sc->ch_state = MCD_S_WAITREAD;
sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
return;
case MCD_S_WAITREAD:
sc->ch_state = MCD_S_WAITREAD;
untimeout(mcd_timeout, (caddr_t)sc, sc->ch);
if (mbx->count-- > 0) {
k = MCD_READ(sc, MCD_FLAGS);
if (!(k & MFL_DATA_NOT_AVAIL)) { /* XXX */
MCD_TRACE("got data delay=%d\n",
RDELAY_WAITREAD-mbx->count);
got_it:
/* data is ready */
addr = bp->bio_data + mbx->skip;
MCD_WRITE(sc, MCD_REG_CTL2,0x04); /* XXX */
for (i=0; i<mbx->sz; i++)
*addr++ = MCD_READ(sc, MCD_REG_RDATA);
MCD_WRITE(sc, MCD_REG_CTL2,0x0c); /* XXX */
k = MCD_READ(sc, MCD_FLAGS);
/* If we still have some junk, read it too */
if (!(k & MFL_DATA_NOT_AVAIL)) {
MCD_WRITE(sc, MCD_REG_CTL2, 0x04); /* XXX */
(void)MCD_READ(sc, MCD_REG_RDATA);
(void)MCD_READ(sc, MCD_REG_RDATA);
MCD_WRITE(sc, MCD_REG_CTL2, 0x0c); /* XXX */
}
if (--mbx->nblk > 0) {
mbx->skip += mbx->sz;
goto nextblock;
}
/* return buffer */
bp->bio_resid = 0;
biodone(bp);
sc->data.flags &= ~(MCDMBXBSY|MCDREADRAW);
mcd_start(sc);
return;
}
if (!(k & MFL_STATUS_NOT_AVAIL)) {
sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
if (sc->data.status & MCD_ST_CMDCHECK)
goto retry_read;
if (mcd_setflags(sc) < 0)
goto changed;
}
sc->ch_state = MCD_S_WAITREAD;
sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
return;
} else {
device_printf(sc->dev, "timeout read data\n");
goto readerr;
}
}
readerr:
if (mbx->retry-- > 0) {
device_printf(sc->dev, "retrying\n");
state = MCD_S_BEGIN1;
goto loop;
}
harderr:
/* invalidate the buffer */
bp->bio_flags |= BIO_ERROR;
bp->bio_resid = bp->bio_bcount;
biodone(bp);
sc->data.flags &= ~(MCDMBXBSY|MCDREADRAW);
mcd_start(sc);
return;
changed:
device_printf(sc->dev, "media changed\n");
goto harderr;
#ifdef NOTDEF
device_printf(sc->dev, "unit timeout, resetting\n");
MCD_WRITE(sc, MCD_REG_RESET, MCD_CMDRESET);
DELAY(300000);
(void)mcd_getstat(sc, 1);
(void)mcd_getstat(sc, 1);
/*sc->data.status &= ~MCDDSKCHNG; */
sc->data.debug = 1; /* preventive set debug mode */
#endif
}
static void
mcdstrategy(struct bio *bp)
{
struct mcd_softc *sc;
int s;
sc = (struct mcd_softc *)bp->bio_dev->si_drv1;
/* test validity */
/*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n",
bp,unit,bp->bio_blkno,bp->bio_bcount);*/
if (bp->bio_blkno < 0) {
device_printf(sc->dev, "strategy failure: blkno = %ld, bcount = %ld\n",
(long)bp->bio_blkno, bp->bio_bcount);
bp->bio_error = EINVAL;
bp->bio_flags |= BIO_ERROR;
goto bad;
}
/* if device invalidated (e.g. media change, door open), error */
if (!(sc->data.flags & MCDVALID)) {
device_printf(sc->dev, "media changed\n");
bp->bio_error = EIO;
goto bad;
}
/* read only */
if (!(bp->bio_cmd == BIO_READ)) {
bp->bio_error = EROFS;
goto bad;
}
/* no data to read */
if (bp->bio_bcount == 0)
goto done;
if (!(sc->data.flags & MCDTOC)) {
bp->bio_error = EIO;
goto bad;
}
bp->bio_pblkno = bp->bio_blkno;
bp->bio_resid = 0;
/* queue it */
s = splbio();
bioqdisksort(&sc->data.head, bp);
splx(s);
/* now check whether we can perform processing */
mcd_start(sc);
return;
bad:
bp->bio_flags |= BIO_ERROR;
done:
bp->bio_resid = bp->bio_bcount;
biodone(bp);
return;
}