Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / dev / disk / scd / scd.c
index caacac7..b799abf 100644 (file)
@@ -42,7 +42,7 @@
 
 
 /* $FreeBSD: src/sys/i386/isa/scd.c,v 1.54 2000/01/29 16:00:30 peter Exp $ */
-/* $DragonFly: src/sys/dev/disk/scd/Attic/scd.c,v 1.11 2004/09/18 19:02:35 dillon Exp $ */
+/* $DragonFly: src/sys/dev/disk/scd/Attic/scd.c,v 1.19 2006/09/10 01:26:34 dillon Exp $ */
 
 /* Please send any comments to micke@dynas.se */
 
@@ -57,6 +57,7 @@
 #include <sys/disklabel.h>
 #include <sys/kernel.h>
 #include <sys/buf2.h>
+#include <sys/thread2.h>
 
 #include <machine/clock.h>
 #include <machine/stdarg.h>
@@ -106,7 +107,7 @@ struct scd_mbx {
        short           nblk;
        int             sz;
        u_long          skip;
-       struct buf      *bp;
+       struct bio      *bio;
        int             p_offset;
        short           count;
 };
@@ -130,7 +131,7 @@ static struct scd_data {
        struct  ioc_play_msf last_play;
 
        short   audio_status;
-       struct buf_queue_head head;             /* head of buf queue */
+       struct bio_queue_head bio_queue;        /* head of bio queue */
        struct scd_mbx mbx;
        struct callout callout;
 } scd_data[NSCD];
@@ -181,23 +182,13 @@ static    d_ioctl_t       scdioctl;
 static d_strategy_t    scdstrategy;
 
 #define CDEV_MAJOR 45
-static struct cdevsw scd_cdevsw = {
-       /* name */      "scd",
-       /* maj */       CDEV_MAJOR,
-       /* flags */     D_DISK,
-       /* port */      NULL,
-       /* clone */     NULL,
-
-       /* open */      scdopen,
-       /* close */     scdclose,
-       /* read */      physread,
-       /* write */     nowrite,
-       /* ioctl */     scdioctl,
-       /* poll */      nopoll,
-       /* mmap */      nommap,
-       /* strategy */  scdstrategy,
-       /* dump */      nodump,
-       /* psize */     nopsize
+static struct dev_ops scd_ops = {
+       { "scd", CDEV_MAJOR, D_DISK },
+       .d_open =       scdopen,
+       .d_close =      scdclose,
+       .d_read =       physread,
+       .d_ioctl =      scdioctl,
+       .d_strategy =   scdstrategy,
 };
 
 
@@ -216,23 +207,24 @@ scd_attach(struct isa_device *dev)
 
        cd->flags = SCDINIT;
        cd->audio_status = CD_AS_AUDIO_INVALID;
-       bufq_init(&cd->head);
+       bioq_init(&cd->bio_queue);
 
-       cdevsw_add(&scd_cdevsw, dkunitmask(), dkmakeunit(unit));
-       make_dev(&scd_cdevsw, dkmakeminor(unit, 0, 0),
+       dev_ops_add(&scd_ops, dkunitmask(), dkmakeunit(unit));
+       make_dev(&scd_ops, dkmakeminor(unit, 0, 0),
            UID_ROOT, GID_OPERATOR, 0640, "rscd%da", unit);
-       make_dev(&scd_cdevsw, dkmakeminor(unit, 0, RAW_PART),
+       make_dev(&scd_ops, dkmakeminor(unit, 0, RAW_PART),
            UID_ROOT, GID_OPERATOR, 0640, "rscd%dc", unit);
-       make_dev(&scd_cdevsw, dkmakeminor(unit, 0, 0),
+       make_dev(&scd_ops, dkmakeminor(unit, 0, 0),
            UID_ROOT, GID_OPERATOR, 0640, "scd%da", unit);
-       make_dev(&scd_cdevsw, dkmakeminor(unit, 0, RAW_PART),
+       make_dev(&scd_ops, dkmakeminor(unit, 0, RAW_PART),
            UID_ROOT, GID_OPERATOR, 0640, "scd%dc", unit);
        return 1;
 }
 
 static int
-scdopen(dev_t dev, int flags, int fmt, struct thread *td)
+scdopen(struct dev_open_args *ap)
 {
+       cdev_t dev = ap->a_head.a_dev;
        int unit,part,phys;
        int rc;
        struct scd_data *cd;
@@ -285,8 +277,9 @@ scdopen(dev_t dev, int flags, int fmt, struct thread *td)
 }
 
 static int
-scdclose(dev_t dev, int flags, int fmt, struct thread *td)
+scdclose(struct dev_close_args *ap)
 {
+       cdev_t dev = ap->a_head.a_dev;
        int unit,part,phys;
        struct scd_data *cd;
 
@@ -313,21 +306,24 @@ scdclose(dev_t dev, int flags, int fmt, struct thread *td)
        return 0;
 }
 
-static void
-scdstrategy(struct buf *bp)
+static int
+scdstrategy(struct dev_strategy_args *ap)
 {
+       cdev_t dev = ap->a_head.a_dev;
+       struct bio *bio = ap->a_bio;
+       struct buf *bp = bio->bio_buf;
+       struct bio *nbio;
        struct scd_data *cd;
-       int s;
-       int unit = scd_unit(bp->b_dev);
+       int unit = scd_unit(dev);
 
        cd = scd_data + unit;
 
-       XDEBUG(2, ("scd%d: DEBUG: strategy: block=%ld, bcount=%ld\n",
-               unit, (long)bp->b_blkno, bp->b_bcount));
+       XDEBUG(2, ("scd%d: DEBUG: strategy: offset=%lld, bcount=%d\n",
+               unit, bio->bio_offset, bp->b_bcount));
 
-       if (unit >= NSCD || bp->b_blkno < 0 || (bp->b_bcount % SCDBLKSIZE)) {
-               printf("scd%d: strategy failure: blkno = %ld, bcount = %ld\n",
-                       unit, (long)bp->b_blkno, bp->b_bcount);
+       if (unit >= NSCD || bio->bio_offset < 0 || (bp->b_bcount % SCDBLKSIZE)) {
+               printf("scd%d: strategy failure: offset = %lld, bcount = %d\n",
+                       unit, bio->bio_offset, bp->b_bcount);
                bp->b_error = EINVAL;
                bp->b_flags |= B_ERROR;
                goto bad;
@@ -341,7 +337,7 @@ scdstrategy(struct buf *bp)
        }
 
        /* read only */
-       if (!(bp->b_flags & B_READ)) {
+       if (bp->b_cmd != BUF_CMD_READ) {
                bp->b_error = EROFS;
                goto bad;
        }
@@ -355,70 +351,73 @@ scdstrategy(struct buf *bp)
                goto bad;
        }
        /* adjust transfer if necessary */
-       if (bounds_check_with_label(bp,&cd->dlabel,1) <= 0)
+       nbio = bounds_check_with_label(dev, bio, &cd->dlabel, 1);
+       if (nbio == NULL)
                goto done;
 
-       bp->b_pblkno = bp->b_blkno;
+       nbio->bio_driver_info = dev;
        bp->b_resid = 0;
 
        /* queue it */
-       s = splbio();
-       bufqdisksort(&cd->head, bp);
-       splx(s);
+       crit_enter();
+       bioqdisksort(&cd->bio_queue, nbio);
+       crit_exit();
 
        /* now check whether we can perform processing */
        scd_start(unit);
-       return;
+       return(0);
 
 bad:
        bp->b_flags |= B_ERROR;
 done:
        bp->b_resid = bp->b_bcount;
-       biodone(bp);
-       return;
+       biodone(bio);
+       return(0);
 }
 
 static void
 scd_start(int unit)
 {
        struct scd_data *cd = scd_data + unit;
-       struct buf *bp;
+       struct bio *bio;
        struct partition *p;
-       int s = splbio();
+       cdev_t dev;
 
+       crit_enter();
        if (cd->flags & SCDMBXBSY) {
-               splx(s);
+               crit_exit();
                return;
        }
 
-       bp = bufq_first(&cd->head);
-       if (bp != 0) {
-               /* block found to process, dequeue */
-               bufq_remove(&cd->head, bp);
-               cd->flags |= SCDMBXBSY;
-               splx(s);
-       } else {
+       bio = bioq_first(&cd->bio_queue);
+       if (bio == NULL) {
                /* nothing to do */
-               splx(s);
+               crit_exit();
                return;
        }
+       /* block found to process, dequeue */
+       bioq_remove(&cd->bio_queue, bio);
+       cd->flags |= SCDMBXBSY;
+       dev = bio->bio_driver_info;
 
-       p = cd->dlabel.d_partitions + scd_part(bp->b_dev);
+       p = cd->dlabel.d_partitions + scd_part(dev);
 
        cd->mbx.unit = unit;
        cd->mbx.port = cd->iobase;
        cd->mbx.retry = 3;
-       cd->mbx.bp = bp;
+       cd->mbx.bio = bio;
        cd->mbx.p_offset = p->p_offset;
-       splx(s);
+       crit_exit();
 
        scd_doread(SCD_S_BEGIN,&(cd->mbx));
        return;
 }
 
 static int
-scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
+scdioctl(struct dev_ioctl_args *ap)
 {
+       cdev_t dev = ap->a_head.a_dev;
+       caddr_t addr = ap->a_data;
        struct scd_data *cd;
        int unit,part;
 
@@ -426,12 +425,12 @@ scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
        part = scd_part(dev);
        cd = scd_data + unit;
 
-       XDEBUG(1, ("scd%d: ioctl: cmd=0x%lx\n", unit, cmd));
+       XDEBUG(1, ("scd%d: ioctl: cmd=0x%lx\n", unit, ap->a_cmd));
 
        if (!(cd->flags & SCDVALID))
                return EIO;
 
-       switch (cmd) {
+       switch (ap->a_cmd) {
        case DIOCGDINFO:
                *(struct disklabel *)addr = cd->dlabel;
                return 0;
@@ -487,7 +486,8 @@ scdioctl(dev_t dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
 #endif
                return 0;
        default:
-               printf("scd%d: unsupported ioctl (cmd=0x%lx)\n", unit, cmd);
+               printf("scd%d: unsupported ioctl (cmd=0x%lx)\n",
+                       unit, ap->a_cmd);
                return ENOTTY;
        }
 }
@@ -793,7 +793,8 @@ scd_doread(int state, struct scd_mbx *mbxin)
        struct scd_mbx *mbx = (state!=SCD_S_BEGIN) ? mbxsave : mbxin;
        int     unit = mbx->unit;
        int     port = mbx->port;
-       struct  buf *bp = mbx->bp;
+       struct  bio *bio = mbx->bio;
+       struct  buf *bp = bio->bio_buf;
        struct  scd_data *cd = scd_data + unit;
        int     reg,i;
        int     blknum;
@@ -844,8 +845,8 @@ nextblock:
                if (!(cd->flags & SCDVALID))
                        goto changed;
 
-               blknum  = (bp->b_blkno / (mbx->sz/DEV_BSIZE))
-                       + mbx->p_offset + mbx->skip/mbx->sz;
+               blknum  = (bio->bio_offset / mbx->sz) +
+                         mbx->p_offset + mbx->skip/mbx->sz;
 
                XDEBUG(2, ("scd%d: scd_doread: read blknum=%d\n", unit, blknum));
 
@@ -1027,7 +1028,7 @@ got_param:
 
                /* return buffer */
                bp->b_resid = 0;
-               biodone(bp);
+               biodone(bio);
 
                cd->flags &= ~SCDMBXBSY;
                scd_start(mbx->unit);
@@ -1045,7 +1046,7 @@ harderr:
        bp->b_error = EIO;
        bp->b_flags |= B_ERROR;
        bp->b_resid = bp->b_bcount;
-       biodone(bp);
+       biodone(bio);
 
        cd->flags &= ~SCDMBXBSY;
        scd_start(mbx->unit);
@@ -1159,27 +1160,18 @@ again:
 static struct sony_tracklist *
 get_tl(struct sony_toc *toc, int size)
 {
+       const char track_list[] = {
+               0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xc0
+       };
        struct sony_tracklist *tl = &toc->tracks[0];
+       size_t i;
 
-       if (tl->track != 0xb0)
-               return tl;
-       (char *)tl += 9;
-       if (tl->track != 0xb1)
-               return tl;
-       (char *)tl += 9;
-       if (tl->track != 0xb2)
-               return tl;
-       (char *)tl += 9;
-       if (tl->track != 0xb3)
-               return tl;
-       (char *)tl += 9;
-       if (tl->track != 0xb4)
-               return tl;
-       (char *)tl += 9;
-       if (tl->track != 0xc0)
-               return tl;
-       (char *)tl += 9;
-       return tl;
+       for (i = 0; i < __arysize(track_list); i++) {
+               if (tl->track != track_list[i])
+                       break;
+               tl = (struct sony_tracklist *)((char *)tl + 9);         
+       }
+       return(tl);
 }
 
 static int