Convert three drivers not covered by any of our kernel configs.

We really need a LINT98 and possibly LINTALPHA kernels.

2 files changed, 58 insertions, 58 deletions

diff --git a/sys/pc98/pc98/wfd.c b/sys/pc98/pc98/wfd.c
index d541bdc..458fffb 100644
--- a/sys/pc98/pc98/wfd.c
+++ b/sys/pc98/pc98/wfd.c
@@ -128,7 +128,7 @@ struct wfd {
 	int flags;                      /* Device state flags */
 	int refcnt;                     /* The number of raw opens */
 	int maxblks;			/* transfer size limit */
-	struct buf_queue_head buf_queue;  /* Queue of i/o requests */
+	struct bio_queue_head buf_queue;  /* Queue of i/o requests */
 	struct atapi_params *param;     /* Drive parameters table */
 	struct cappage cap;             /* Capabilities page info */
 	char description[80];           /* Device description */
@@ -141,7 +141,7 @@ static struct wfd *wfdtab[NUNIT]; /* Drive info by unit number */
 static int wfdnlun = 0;           /* Number of configured drives */
 
 static void wfd_start (struct wfd *t);
-static void wfd_done (struct wfd *t, struct buf *bp, int resid,
+static void wfd_done (struct wfd *t, struct bio *bp, int resid,
 	struct atapires result);
 static void wfd_error (struct wfd *t, struct atapires result);
 static int wfd_request_wait (struct wfd *t, u_char cmd, u_char a1, u_char a2,
@@ -186,7 +186,7 @@ wfdattach (struct atapi *ata, int unit, struct atapi_params *ap, int debug)
 	}
 	wfdtab[wfdnlun] = t;
 	bzero (t, sizeof (struct wfd));
-	bufq_init(&t->buf_queue);
+	bioq_init(&t->buf_queue);
 	t->ata = ata;
 	t->unit = unit;
 	lun = t->lun = wfdnlun;
@@ -397,21 +397,21 @@ int wfdclose (dev_t dev, int flags, int fmt, struct proc *p)
  * understand. The transfer is described by a buf and will include only one
  * physical transfer.
  */
-void wfdstrategy (struct buf *bp)
+void wfdstrategy (struct bio *bp)
 {
-	int lun = UNIT(bp->b_dev);
+	int lun = UNIT(bp->bio_dev);
 	struct wfd *t = wfdtab[lun];
 	int x;
 
 	/* If it's a null transfer, return immediatly. */
-	if (bp->b_bcount == 0) {
-		bp->b_resid = 0;
+	if (bp->bio_bcount == 0) {
+		bp->bio_resid = 0;
 		biodone (bp);
 		return;
 	}
 
 	/*
-	 * Do bounds checking, adjust transfer, and set b_pblkno.
+	 * Do bounds checking, adjust transfer, and set bio_pblkno.
          */
 	if (dscheck(bp, t->dk_slices) <= 0) {
 		biodone(bp);
@@ -421,7 +421,7 @@ void wfdstrategy (struct buf *bp)
 	x = splbio();
 
 	/* Place it in the queue of disk activities for this disk. */
-	bufqdisksort (&t->buf_queue, bp);
+	bioqdisksort (&t->buf_queue, bp);
 
 	/* Tell the device to get going on the transfer if it's
 	 * not doing anything, otherwise just wait for completion. */
@@ -439,7 +439,7 @@ void wfdstrategy (struct buf *bp)
  */
 static void wfd_start (struct wfd *t)
 {
-	struct buf *bp = bufq_first(&t->buf_queue);
+	struct bio *bp = bioq_first(&t->buf_queue);
 	u_long blkno, nblk;
 	u_char op_code;
 	long count;
@@ -452,7 +452,7 @@ static void wfd_start (struct wfd *t)
 		return;
 
 	/* Unqueue the request. */
-	bufq_remove(&t->buf_queue, bp);
+	bioq_remove(&t->buf_queue, bp);
 
 	/* Tell devstat we are starting on the transaction */
 	devstat_start_transaction(&t->device_stats);
@@ -460,27 +460,27 @@ static void wfd_start (struct wfd *t)
 	/* We have a buf, now we should make a command
 	 * First, translate the block to absolute and put it in terms of the
 	 * logical blocksize of the device. */
-	blkno = bp->b_pblkno / (t->cap.sector_size / 512);
-	nblk = (bp->b_bcount + (t->cap.sector_size - 1)) / t->cap.sector_size;
+	blkno = bp->bio_pblkno / (t->cap.sector_size / 512);
+	nblk = (bp->bio_bcount + (t->cap.sector_size - 1)) / t->cap.sector_size;
 
 	if ((t->maxblks == 0) || (nblk <= t->maxblks)) {
 
-		if(bp->b_flags & B_READ) {
+		if(bp->bio_cmd & BIO_READ) {
 			op_code = ATAPI_READ_BIG;
-			count = bp->b_bcount;
+			count = bp->bio_bcount;
 		} else {
 			op_code = ATAPI_WRITE_BIG;
-			count = -bp->b_bcount;
+			count = -bp->bio_bcount;
 		}
 
 		/* only one transfer */
-		(int)bp->b_driver1 = 0;
-		(int)bp->b_driver2 = 0;
+		(int)bp->bio_driver1 = 0;
+		(int)bp->bio_driver2 = 0;
 		atapi_request_callback (t->ata, t->unit, op_code, 0,
 					blkno>>24, blkno>>16, blkno>>8, blkno,
 					0, nblk>>8, nblk, 0, 0,
 					0, 0, 0, 0, 0, 
-					(u_char*) bp->b_data, count, 
+					(u_char*) bp->bio_data, count, 
 					(void*)wfd_done, t, bp);
 	} else {
 
@@ -488,22 +488,22 @@ static void wfd_start (struct wfd *t)
 		 * We can't handle this request in a single
 		 * read/write operation.  Instead, queue a set of
 		 * transfers, and record the number of transfers
-		 * and the running residual in the b_driver
+		 * and the running residual in the bio_driver
 		 * fields of the bp.
 		 */ 
 
-		if(bp->b_flags & B_READ) {
+		if(bp->bio_cmd & BIO_READ) {
 			op_code = ATAPI_READ_BIG;
 		} else {
 			op_code = ATAPI_WRITE_BIG;
 		}
 
 		/* calculate number of transfers */
-		(int)bp->b_driver1 = (nblk - 1) / t->maxblks;
-		(int)bp->b_driver2 = 0;
+		(int)bp->bio_driver1 = (nblk - 1) / t->maxblks;
+		(int)bp->bio_driver2 = 0;
 
-		pxdest = (u_char *)bp->b_data;
-		pxcount = bp->b_bcount;
+		pxdest = (u_char *)bp->bio_data;
+		pxcount = bp->bio_bcount;
 
 		/* construct partial transfer requests */
 		while (nblk > 0) {
@@ -515,7 +515,7 @@ static void wfd_start (struct wfd *t)
 					       blkno, 0, pxnblk>>8, pxnblk, 
 					       0, 0, 0, 0, 0, 0, 0,
 					       pxdest, 
-					       (bp->b_flags & B_READ) ?
+					       (bp->bio_cmd & BIO_READ) ?
 					       count : -count, 
 					       (void*)wfd_done, t, bp);
 			nblk -= pxnblk;
@@ -526,25 +526,25 @@ static void wfd_start (struct wfd *t)
 	}
 }
 
-static void wfd_done (struct wfd *t, struct buf *bp, int resid,
+static void wfd_done (struct wfd *t, struct bio *bp, int resid,
 	struct atapires result)
 {
 		
 	if (result.code) {
 		wfd_error (t, result);
-		bp->b_error = EIO;
-		bp->b_ioflags |= BIO_ERROR;
+		bp->bio_error = EIO;
+		bp->bio_flags |= BIO_ERROR;
 	} else
-		(int)bp->b_driver2 += resid;
+		(int)bp->bio_driver2 += resid;
 	/*
 	 * We can't call biodone until all outstanding
 	 * transfer fragments are handled.  If one hits
 	 * an error, we will be returning an error, but
 	 * only when all are complete.
 	 */
-	if (((int)bp->b_driver1)-- <= 0) {
-		bp->b_resid = (int)bp->b_driver2;
-		devstat_end_transaction_buf(&t->device_stats, bp);
+	if (((int)bp->bio_driver1)-- <= 0) {
+		bp->bio_resid = (int)bp->bio_driver2;
+		devstat_end_transaction_bio(&t->device_stats, bp);
 		biodone (bp);
 	}
 	
diff --git a/sys/pc98/pc98/wst.c b/sys/pc98/pc98/wst.c
index 59b0cdf..412a56b 100644
--- a/sys/pc98/pc98/wst.c
+++ b/sys/pc98/pc98/wst.c
@@ -179,7 +179,7 @@ struct wst {
     int lun;                		/* Logical device unit */
     int flags;              		/* Device state flags */
     int blksize;                	/* Block size (512 | 1024) */
-    struct buf_queue_head buf_queue;    /* Queue of i/o requests */
+    struct bio_queue_head buf_queue;    /* Queue of i/o requests */
     struct atapi_params *param;     	/* Drive parameters table */
     struct wst_header header;       	/* MODE SENSE param header */
     struct wst_cappage cap;         	/* Capabilities page info */
@@ -193,7 +193,7 @@ static int wst_sense(struct wst *t);
 static void wst_describe(struct wst *t);
 static void wst_poll_dsc(struct wst *t);
 static void wst_start(struct wst *t);
-static void wst_done(struct wst *t, struct buf *bp, int resid, struct atapires result);
+static void wst_done(struct wst *t, struct bio *bp, int resid, struct atapires result);
 static int wst_error(struct wst *t, struct atapires result);
 static void wst_drvinit(void *unused);
 static int wst_space_cmd(struct wst *t, u_char function, u_int count);
@@ -241,7 +241,7 @@ wstattach(struct atapi *ata, int unit, struct atapi_params *ap, int debug)
     }
     wsttab[wstnlun] = t;
     bzero(t, sizeof(struct wst));
-    bufq_init(&t->buf_queue);
+    bioq_init(&t->buf_queue);
     t->ata = ata;
     t->unit = unit;
     t->ata->use_dsc = 1;
@@ -380,39 +380,39 @@ wstclose(dev_t dev, int flags, int fmt, struct proc *p)
 }
 
 void 
-wststrategy(struct buf *bp)
+wststrategy(struct bio *bp)
 {
-    int lun = UNIT(bp->b_dev);
+    int lun = UNIT(bp->bio_dev);
     struct wst *t = wsttab[lun];
     int x;
 
     /* If it's a null transfer, return immediatly. */
-    if (bp->b_bcount == 0) {
-        bp->b_resid = 0;
+    if (bp->bio_bcount == 0) {
+        bp->bio_resid = 0;
         biodone(bp);
         return;
     }
 
     /* Check for != blocksize requests */
-    if (bp->b_bcount % t->blksize) {
+    if (bp->bio_bcount % t->blksize) {
         printf("wst%d: bad request, must be multiple of %d\n", lun, t->blksize);
-        bp->b_error = EIO;
-	bp->b_ioflags |= BIO_ERROR;
+        bp->bio_error = EIO;
+	bp->bio_flags |= BIO_ERROR;
         biodone(bp);
         return;
     }
 
-    if (bp->b_bcount > t->blksize*t->cap.ctl) {  
+    if (bp->bio_bcount > t->blksize*t->cap.ctl) {  
 	if ((t->flags & WST_CTL_WARN) == 0) {
             printf("wst%d: WARNING: CTL exceeded %ld>%d\n", 
-		    lun, bp->b_bcount, t->blksize*t->cap.ctl);
+		    lun, bp->bio_bcount, t->blksize*t->cap.ctl);
 	    t->flags |= WST_CTL_WARN;
 	}
     }
 
     x = splbio();
-    wst_total += bp->b_bcount;
-    bufq_insert_tail(&t->buf_queue, bp);
+    wst_total += bp->bio_bcount;
+    bioq_insert_tail(&t->buf_queue, bp);
     wst_start(t);
     splx(x);
 }
@@ -432,7 +432,7 @@ wst_poll_dsc(struct wst *t)
 static void 
 wst_start(struct wst *t)
 {
-    struct buf *bp = bufq_first(&t->buf_queue);
+    struct bio *bp = bioq_first(&t->buf_queue);
     u_long blk_count;
     u_char op_code;
     long byte_count;
@@ -450,37 +450,37 @@ wst_start(struct wst *t)
         tsleep((caddr_t) t, 0, "wstdsc", 0);
     }
 
-    bufq_remove(&t->buf_queue, bp);
-    blk_count = bp->b_bcount / t->blksize;
+    bioq_remove(&t->buf_queue, bp);
+    blk_count = bp->bio_bcount / t->blksize;
 
-    if (bp->b_flags & B_READ) {
+    if (bp->bio_cmd & BIO_READ) {
         op_code = ATAPI_TAPE_READ_CMD;
-        byte_count = bp->b_bcount;
+        byte_count = bp->bio_bcount;
     } else {
         op_code = ATAPI_TAPE_WRITE_CMD;
 	t->flags |= WST_DATA_WRITTEN;
-        byte_count = -bp->b_bcount;
+        byte_count = -bp->bio_bcount;
     }
 
     atapi_request_callback(t->ata, t->unit, op_code, 1,
                     	   blk_count>>16, blk_count>>8, blk_count,
                     	   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                    	   (u_char*) bp->b_data, byte_count, 
+                    	   (u_char*) bp->bio_data, byte_count, 
                     	   (void*)wst_done, t, bp);
 }
 
 static void 
-wst_done(struct wst *t, struct buf *bp, int resid,
+wst_done(struct wst *t, struct bio *bp, int resid,
     struct atapires result)
 {
     if (result.code) {
 	printf("wst_done: ");
         wst_error(t, result);
-        bp->b_error = EIO;
-        bp->b_ioflags |= BIO_ERROR;
+        bp->bio_error = EIO;
+        bp->bio_flags |= BIO_ERROR;
     }
     else
-	bp->b_resid = resid;
+	bp->bio_resid = resid;
 
     biodone(bp);
     /*wst_start(t);*/