More low-hanging fruit: kill caddr_t in calls to wakeup(9) / [mt]sleep(9).

21 files changed, 57 insertions, 57 deletions

diff --git a/sys/dev/asr/asr.c b/sys/dev/asr/asr.c
index ad02eb6..78cf0a2 100644
--- a/sys/dev/asr/asr.c
+++ b/sys/dev/asr/asr.c
@@ -1101,7 +1101,7 @@ ASR_failActiveCommands (
 		if (ccb->path) {
 			xpt_done ((union ccb *)ccb);
 		} else {
-			wakeup ((caddr_t)ccb);
+			wakeup (ccb);
 		}
 	}
 	splx(s);
@@ -3798,7 +3798,7 @@ asr_intr (
 		if (ccb->ccb_h.path) {
 			xpt_done ((union ccb *)ccb);
 		} else {
-			wakeup ((caddr_t)ccb);
+			wakeup (ccb);
 		}
 	}
 #ifdef ASR_MEASURE_PERFORMANCE
@@ -4313,7 +4313,7 @@ ASR_queue_i(
 		}
 		/* Check every second for BlinkLed */
 		/* There is no PRICAM, but outwardly PRIBIO is functional */
-		tsleep((caddr_t)ccb, PRIBIO, "asr", hz);
+		tsleep(ccb, PRIBIO, "asr", hz);
 	}
 	splx(s);
 
diff --git a/sys/dev/ata/ata-all.c b/sys/dev/ata/ata-all.c
index 17bddd4..34cf1df 100644
--- a/sys/dev/ata/ata-all.c
+++ b/sys/dev/ata/ata-all.c
@@ -629,7 +629,7 @@ ata_intr(void *data)
 #endif
     default:
 	if (ch->active & ATA_WAIT_INTR)
-	    wakeup((caddr_t)ch);
+	    wakeup(ch);
     }
 
     if (ch->active & ATA_CONTROL) {
@@ -1113,7 +1113,7 @@ ata_command(struct ata_device *atadev, u_int8_t command,
 	if (atadev->channel->flags & ATA_QUEUED)
 	    ATA_OUTB(atadev->channel->r_altio, ATA_ALTSTAT, ATA_A_4BIT);
 
-	if (tsleep((caddr_t)atadev->channel, PRIBIO, "atacmd", 10 * hz)) {
+	if (tsleep(atadev->channel, PRIBIO, "atacmd", 10 * hz)) {
 	    ata_prtdev(atadev, "timeout waiting for interrupt\n");
 	    atadev->channel->active &= ~ATA_WAIT_INTR;
 	    error = -1;
diff --git a/sys/dev/ata/ata-chipset.c b/sys/dev/ata/ata-chipset.c
index 8078e21..7614254 100644
--- a/sys/dev/ata/ata-chipset.c
+++ b/sys/dev/ata/ata-chipset.c
@@ -1865,14 +1865,14 @@ ata_pci_serialize(struct ata_channel *ch, int flags)
 	if (scp->locked_ch == ch->unit)
 	    break;
 	while (!atomic_cmpset_acq_int(&scp->locked_ch, -1, ch->unit))
-	    tsleep((caddr_t)ch->locking, PRIBIO, "atalck", 1);
+	    tsleep(ch->locking, PRIBIO, "atalck", 1);
 	break;
 
     case ATA_LF_UNLOCK:
 	if (scp->locked_ch == -1 || scp->locked_ch != ch->unit)
 	    break;
 	atomic_store_rel_int(&scp->locked_ch, -1);
-	wakeup((caddr_t)ch->locking);
+	wakeup(ch->locking);
 	break;
     }
     return;
diff --git a/sys/dev/ata/atapi-all.c b/sys/dev/ata/atapi-all.c
index d39c69b..4bccf38 100644
--- a/sys/dev/ata/atapi-all.c
+++ b/sys/dev/ata/atapi-all.c
@@ -202,7 +202,7 @@ atapi_queue_cmd(struct ata_device *atadev, int8_t *ccb, caddr_t data,
 
     /* only sleep when command is in progress */
     if (request->error == EINPROGRESS)
-	tsleep((caddr_t)request, PRIBIO, "atprq", 0);
+	tsleep(request, PRIBIO, "atprq", 0);
     splx(s);
     error = request->error;
     if (error)
@@ -489,7 +489,7 @@ atapi_wait_dsc(struct ata_device *atadev, int timeout)
 	error = atapi_queue_cmd(atadev, ccb, NULL, 0, 0, 0, NULL, NULL);
 	if (error != EBUSY)
 	    break;
-	tsleep((caddr_t)&error, PRIBIO, "atpwt", hz / 2);
+	tsleep(&error, PRIBIO, "atpwt", hz / 2);
 	timeout -= (hz / 2);
     }
     return error;
@@ -577,7 +577,7 @@ atapi_finish(struct atapi_request *request)
 	    free(request, M_ATAPI);
     }
     else 
-	wakeup((caddr_t)request);	
+	wakeup(request);	
 }
 
 static void 
@@ -608,7 +608,7 @@ atapi_timeout(struct atapi_request *request)
     else {
 	/* retries all used up, return error */
 	request->error = EIO;
-	wakeup((caddr_t)request);
+	wakeup(request);
     } 
     ata_reinit(atadev->channel);
 }
diff --git a/sys/dev/atkbdc/psm.c b/sys/dev/atkbdc/psm.c
index bec4448..5b4cc20 100644
--- a/sys/dev/atkbdc/psm.c
+++ b/sys/dev/atkbdc/psm.c
@@ -1528,7 +1528,7 @@ psmread(dev_t dev, struct uio *uio, int flag)
             return EWOULDBLOCK;
         }
         sc->state |= PSM_ASLP;
-        error = tsleep((caddr_t) sc, PZERO | PCATCH, "psmrea", 0);
+        error = tsleep( sc, PZERO | PCATCH, "psmrea", 0);
         sc->state &= ~PSM_ASLP;
         if (error) {
             splx(s);
@@ -2366,7 +2366,7 @@ psmintr(void *arg)
 
         if (sc->state & PSM_ASLP) {
             sc->state &= ~PSM_ASLP;
-            wakeup((caddr_t) sc);
+            wakeup( sc);
     	}
         selwakeup(&sc->rsel);
     }
@@ -2821,7 +2821,7 @@ psmresume(device_t dev)
 	 * cannot be accessed anymore.
 	 */
         sc->state &= ~PSM_ASLP;
-        wakeup((caddr_t)sc);
+        wakeup(sc);
     }
 
     if (verbose >= 2)
diff --git a/sys/dev/dgb/dgb.c b/sys/dev/dgb/dgb.c
index 65d2a25..1f10380 100644
--- a/sys/dev/dgb/dgb.c
+++ b/sys/dev/dgb/dgb.c
@@ -1231,7 +1231,7 @@ static void
 dgb_pause(chan)
 	void *chan;
 {
-	wakeup((caddr_t)chan);
+	wakeup(chan);
 }
 
 static void
diff --git a/sys/dev/firewire/fwdev.c b/sys/dev/firewire/fwdev.c
index a25af15..36464ab 100644
--- a/sys/dev/firewire/fwdev.c
+++ b/sys/dev/firewire/fwdev.c
@@ -253,7 +253,7 @@ readloop:
 					return err;
 			}
 			ir->flag |= FWXFERQ_WAKEUP;
-			err = tsleep((caddr_t)ir, FWPRI, "fw_read", hz);
+			err = tsleep(ir, FWPRI, "fw_read", hz);
 			ir->flag &= ~FWXFERQ_WAKEUP;
 			if (err == 0)
 				goto readloop;
@@ -375,7 +375,7 @@ isoloop:
 				err = sc->fc->itx_enable(sc->fc, sub);
 				if (err)
 					return err;
-				err = tsleep((caddr_t)it, FWPRI,
+				err = tsleep(it, FWPRI,
 							"fw_write", hz);
 				if (err)
 					return err;
@@ -420,7 +420,7 @@ dvloop:
 				if(err){
 					return err;
 				}
-				err = tsleep((caddr_t)it, FWPRI, "fw_write", hz);
+				err = tsleep(it, FWPRI, "fw_write", hz);
 				if(err){
 					return err;
 				}
@@ -503,7 +503,7 @@ dvloop:
 #else
 		fw_asyreq(fc, -1, xfer);
 #endif
-		err = tsleep((caddr_t)xfer, FWPRI, "fw_write", hz);
+		err = tsleep(xfer, FWPRI, "fw_write", hz);
 		if(xfer->resp == EBUSY)
 			return EBUSY;
 		fw_xfer_free( xfer);
@@ -777,7 +777,7 @@ fw_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, fw_proc *td)
 			fw_xfer_free( xfer);
 			return err;
 		}
-		err = tsleep((caddr_t)xfer, FWPRI, "asyreq", hz);
+		err = tsleep(xfer, FWPRI, "asyreq", hz);
 		if(err == 0){
 			if(asyreq->req.len >= xfer->recv.len){
 				asyreq->req.len = xfer->recv.len;
diff --git a/sys/dev/hfa/fore_command.c b/sys/dev/hfa/fore_command.c
index 8616112..e73091f 100644
--- a/sys/dev/hfa/fore_command.c
+++ b/sys/dev/hfa/fore_command.c
@@ -329,7 +329,7 @@ fore_cmd_drain(fup)
 			/*
 			 * Poke whoever is waiting on the stats
 			 */
-			wakeup((caddr_t)&fup->fu_stats);
+			wakeup(&fup->fu_stats);
 			break;
 
 		case CMD_GET_PROM:
@@ -416,7 +416,7 @@ fore_cmd_free(fup)
 				 * Just in case someone is sleeping on this
 				 */
 				fup->fu_stats_ret = EIO;
-				wakeup((caddr_t)&fup->fu_stats);
+				wakeup(&fup->fu_stats);
 				break;
 			}
 
diff --git a/sys/dev/ida/ida.c b/sys/dev/ida/ida.c
index f7c026f..2f725b1 100644
--- a/sys/dev/ida/ida.c
+++ b/sys/dev/ida/ida.c
@@ -445,7 +445,7 @@ ida_wait(struct ida_softc *ida, struct ida_qcb *qcb)
 	int delay;
 
 	if (ida->flags & IDA_INTERRUPTS) {
-		if (tsleep((caddr_t)qcb, PRIBIO, "idacmd", 5 * hz))
+		if (tsleep(qcb, PRIBIO, "idacmd", 5 * hz))
 			return (ETIMEDOUT);
 		return (0);
 	}
diff --git a/sys/dev/kbd/kbd.c b/sys/dev/kbd/kbd.c
index 6eef728..aa4c3f7 100644
--- a/sys/dev/kbd/kbd.c
+++ b/sys/dev/kbd/kbd.c
@@ -578,7 +578,7 @@ genkbdread(dev_t dev, struct uio *uio, int flag)
 			return EWOULDBLOCK;
 		}
 		sc->gkb_flags |= KB_ASLEEP;
-		error = tsleep((caddr_t)sc, PZERO | PCATCH, "kbdrea", 0);
+		error = tsleep(sc, PZERO | PCATCH, "kbdrea", 0);
 		kbd = kbd_get_keyboard(KBD_INDEX(dev));
 		if ((kbd == NULL) || !KBD_IS_VALID(kbd)) {
 			splx(s);
@@ -677,7 +677,7 @@ genkbd_event(keyboard_t *kbd, int event, void *arg)
 		kbd_release(kbd, (void *)sc);
 		if (sc->gkb_flags & KB_ASLEEP) {
 			sc->gkb_flags &= ~KB_ASLEEP;
-			wakeup((caddr_t)sc);
+			wakeup(sc);
 		}
 		selwakeup(&sc->gkb_rsel);
 		return 0;
@@ -748,7 +748,7 @@ genkbd_event(keyboard_t *kbd, int event, void *arg)
 	if (sc->gkb_q.c_cc > 0) {
 		if (sc->gkb_flags & KB_ASLEEP) {
 			sc->gkb_flags &= ~KB_ASLEEP;
-			wakeup((caddr_t)sc);
+			wakeup(sc);
 		}
 		selwakeup(&sc->gkb_rsel);
 	}
diff --git a/sys/dev/mse/mse.c b/sys/dev/mse/mse.c
index 3887ba1..17622bd 100644
--- a/sys/dev/mse/mse.c
+++ b/sys/dev/mse/mse.c
@@ -474,7 +474,7 @@ mseread(dev, uio, ioflag)
 				return (0);
 			}
 			sc->sc_flags |= MSESC_WANT;
-			error = tsleep((caddr_t)sc, MSEPRI | PCATCH,
+			error = tsleep(sc, MSEPRI | PCATCH,
 				"mseread", 0);
 			if (error) {
 				splx(s);
@@ -753,7 +753,7 @@ mseintr(arg)
 	    (sc->sc_obuttons ^ sc->sc_buttons) != 0) {
 		if (sc->sc_flags & MSESC_WANT) {
 			sc->sc_flags &= ~MSESC_WANT;
-			wakeup((caddr_t)sc);
+			wakeup(sc);
 		}
 		selwakeup(&sc->sc_selp);
 	}
diff --git a/sys/dev/pcic/i82365.c b/sys/dev/pcic/i82365.c
index fc3c623..3ca13f2 100644
--- a/sys/dev/pcic/i82365.c
+++ b/sys/dev/pcic/i82365.c
@@ -511,7 +511,7 @@ pcic_event_thread(void *arg)
 		} else {
 			splx(s);
 			/* sleep .25s to be enqueued chatterling interrupts */
-			(void) tsleep((caddr_t)pcic_event_thread, PWAIT, "pcicss", hz/4);
+			(void) tsleep(pcic_event_thread, PWAIT, "pcicss", hz/4);
 		}
 		s = splhigh();
 		STAILQ_REMOVE_HEAD_UNTIL(&h->events, pe, pe_q);
diff --git a/sys/dev/ppbus/lpt.c b/sys/dev/ppbus/lpt.c
index 9364c50..43fda7e 100644
--- a/sys/dev/ppbus/lpt.c
+++ b/sys/dev/ppbus/lpt.c
@@ -444,7 +444,7 @@ lptout(void *arg)
 		lptintr(dev);
 	} else {
 		sc->sc_state &= ~OBUSY;
-		wakeup((caddr_t)dev);
+		wakeup(dev);
 	}
 }
 
@@ -523,7 +523,7 @@ lptopen(dev_t dev, int flags, int fmt, struct thread *td)
 		}
 
 		/* wait 1/4 second, give up if we get a signal */
-		if (tsleep((caddr_t)lptdev, LPPRI|PCATCH, "lptinit", hz/4) !=
+		if (tsleep(lptdev, LPPRI|PCATCH, "lptinit", hz/4) !=
 		    EWOULDBLOCK) {
 			sc->sc_state = 0;
 			splx(s);
@@ -597,7 +597,7 @@ lptclose(dev_t dev, int flags, int fmt, struct thread *td)
 			(LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
 			(LPS_SEL|LPS_NBSY|LPS_NERR) || sc->sc_xfercnt)
 			/* wait 1/4 second, give up if we get a signal */
-			if (tsleep((caddr_t)lptdev, LPPRI|PCATCH,
+			if (tsleep(lptdev, LPPRI|PCATCH,
 				"lpclose", hz) != EWOULDBLOCK)
 				break;
 
@@ -661,7 +661,7 @@ lpt_pushbytes(device_t dev)
 				 */
 				if (tic > MAX_SLEEP)
 					tic = MAX_SLEEP;
-				err = tsleep((caddr_t)dev, LPPRI,
+				err = tsleep(dev, LPPRI,
 					LPT_NAME "poll", tic);
 				if (err != EWOULDBLOCK) {
 					return (err);
@@ -796,7 +796,7 @@ lptwrite(dev_t dev, struct uio *uio, int ioflag)
 			}
 			lprintf(("W "));
 			if (sc->sc_state & OBUSY)
-				if ((err = tsleep((caddr_t)lptdev,
+				if ((err = tsleep(lptdev,
 					 LPPRI|PCATCH, LPT_NAME "write", 0))) {
 					sc->sc_state |= INTERRUPTED;
 					return(err);
@@ -872,7 +872,7 @@ lpt_intr(void *arg)
 		sc->sc_state &= ~OBUSY;
 
 		if(!(sc->sc_state & INTERRUPTED))
-			wakeup((caddr_t)lptdev);
+			wakeup(lptdev);
 		lprintf(("w "));
 		return;
 	} else	{	/* check for error */
diff --git a/sys/dev/ppc/ppc.c b/sys/dev/ppc/ppc.c
index 52c2f6a..690d0cc 100644
--- a/sys/dev/ppc/ppc.c
+++ b/sys/dev/ppc/ppc.c
@@ -1614,7 +1614,7 @@ ppcintr(void *arg)
 				ppc->ppc_dmastat = PPC_DMA_COMPLETE;
 
 				/* wakeup the waiting process */
-				wakeup((caddr_t)ppc);
+				wakeup(ppc);
 			}
 		}
 	} else if (ppc->ppc_irqstat & PPC_IRQ_FIFO) {
@@ -1720,7 +1720,7 @@ ppc_write(device_t dev, char *buf, int len, int how)
 		 */
 		do {
 			/* release CPU */
-			error = tsleep((caddr_t)ppc,
+			error = tsleep(ppc,
 				PPBPRI | PCATCH, "ppcdma", 0);
 
 		} while (error == EWOULDBLOCK);
@@ -1752,7 +1752,7 @@ ppc_write(device_t dev, char *buf, int len, int how)
 #ifdef PPC_DEBUG
 			printf("Z");
 #endif
-			error = tsleep((caddr_t)ppc, PPBPRI | PCATCH, "ppcfifo", hz/100);
+			error = tsleep(ppc, PPBPRI | PCATCH, "ppcfifo", hz/100);
 			if (error != EWOULDBLOCK) {
 #ifdef PPC_DEBUG
 				printf("I");
diff --git a/sys/dev/rc/rc.c b/sys/dev/rc/rc.c
index 40178ec..1e4df70 100644
--- a/sys/dev/rc/rc.c
+++ b/sys/dev/rc/rc.c
@@ -1007,7 +1007,7 @@ rc_hardclose(struct rc_chans *rc)
 		}
 	}
 	rc->rc_flags &= ~RC_ACTOUT;
-	wakeup((caddr_t) &rc->rc_rcb);  /* wake bi */
+	wakeup( &rc->rc_rcb);  /* wake bi */
 	wakeup(TSA_CARR_ON(tp));
 	(void) splx(s);
 }
diff --git a/sys/dev/si/si.c b/sys/dev/si/si.c
index 84750bc..b96d84f 100644
--- a/sys/dev/si/si.c
+++ b/sys/dev/si/si.c
@@ -850,7 +850,7 @@ sihardclose(struct si_port *pp)
 
 	}
 	pp->sp_active_out = FALSE;
-	wakeup((caddr_t)&pp->sp_active_out);
+	wakeup(&pp->sp_active_out);
 	wakeup(TSA_CARR_ON(tp));
 
 	splx(oldspl);
@@ -1416,7 +1416,7 @@ si_write_enable(struct si_port *pp, int state)
 		if (pp->sp_state & SS_WAITWRITE) {
 			pp->sp_state &= ~SS_WAITWRITE;
 			/* thunder away! */
-			wakeup((caddr_t)pp);
+			wakeup(pp);
 		}
 	} else {
 		pp->sp_state |= SS_BLOCKWRITE;
diff --git a/sys/dev/snp/snp.c b/sys/dev/snp/snp.c
index c68ca4a..797b8d8 100644
--- a/sys/dev/snp/snp.c
+++ b/sys/dev/snp/snp.c
@@ -257,7 +257,7 @@ snpread(dev, uio, flag)
 			if (flag & IO_NDELAY)
 				return (EWOULDBLOCK);
 			snp->snp_flags |= SNOOP_RWAIT;
-			error = tsleep((caddr_t)snp, (PZERO + 1) | PCATCH,
+			error = tsleep(snp, (PZERO + 1) | PCATCH,
 			    "snprd", 0);
 			if (error != 0)
 				return (error);
@@ -351,7 +351,7 @@ snp_in(snp, buf, n)
 			snp->snp_flags |= SNOOP_OFLOW;
 			if (snp->snp_flags & SNOOP_RWAIT) {
 				snp->snp_flags &= ~SNOOP_RWAIT;
-				wakeup((caddr_t)snp);
+				wakeup(snp);
 			}
 			splx(s);
 			return (0);
@@ -371,7 +371,7 @@ snp_in(snp, buf, n)
 
 	if (snp->snp_flags & SNOOP_RWAIT) {
 		snp->snp_flags &= ~SNOOP_RWAIT;
-		wakeup((caddr_t)snp);
+		wakeup(snp);
 	}
 	selwakeup(&snp->snp_sel);
 
diff --git a/sys/dev/speaker/spkr.c b/sys/dev/speaker/spkr.c
index de4c5ca..22b6bf3 100644
--- a/sys/dev/speaker/spkr.c
+++ b/sys/dev/speaker/spkr.c
@@ -140,7 +140,7 @@ tone(thz, ticks)
      * emitted.
      */
     if (ticks > 0)
-	tsleep((caddr_t)&endtone, SPKRPRI | PCATCH, "spkrtn", ticks);
+	tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", ticks);
     SPEAKER_OFF;
     sps = splclock();
     TIMER_RELEASE;
@@ -161,7 +161,7 @@ rest(ticks)
     (void) printf("rest: %d\n", ticks);
 #endif /* DEBUG */
     if (ticks > 0)
-	tsleep((caddr_t)&endrest, SPKRPRI | PCATCH, "spkrrs", ticks);
+	tsleep(&endrest, SPKRPRI | PCATCH, "spkrrs", ticks);
 }
 
 /**************** PLAY STRING INTERPRETER BEGINS HERE **********************
@@ -548,8 +548,8 @@ spkrclose(dev, flags, fmt, td)
 	return(ENXIO);
     else
     {
-	wakeup((caddr_t)&endtone);
-	wakeup((caddr_t)&endrest);
+	wakeup(&endtone);
+	wakeup(&endrest);
 	free(spkr_inbuf, M_SPKR);
 	spkr_active = FALSE;
 	return(0);
diff --git a/sys/dev/syscons/syscons.c b/sys/dev/syscons/syscons.c
index 22294db..0edbc49 100644
--- a/sys/dev/syscons/syscons.c
+++ b/sys/dev/syscons/syscons.c
@@ -1012,7 +1012,7 @@ scioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct thread *td)
 	scp = SC_STAT(SC_DEV(sc, i));
 	if (scp == scp->sc->cur_scp)
 	    return 0;
-	while ((error=tsleep((caddr_t)&scp->smode, PZERO|PCATCH,
+	while ((error=tsleep(&scp->smode, PZERO|PCATCH,
 			     "waitvt", 0)) == ERESTART) ;
 	return error;
 
@@ -2089,7 +2089,7 @@ stop_scrn_saver(sc_softc_t *sc, void (*saver)(sc_softc_t *, int))
     if (sc->delayed_next_scr)
 	sc_switch_scr(sc, sc->delayed_next_scr - 1);
     if (debugger == 0)
-	wakeup((caddr_t)&scrn_blanked);
+	wakeup(&scrn_blanked);
 }
 
 static int
@@ -2103,7 +2103,7 @@ wait_scrn_saver_stop(sc_softc_t *sc)
 	    error = 0;
 	    break;
 	}
-	error = tsleep((caddr_t)&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
+	error = tsleep(&scrn_blanked, PZERO | PCATCH, "scrsav", 0);
 	if ((error != 0) && (error != ERESTART))
 	    break;
     }
@@ -2302,7 +2302,7 @@ sc_switch_scr(sc_softc_t *sc, u_int next_scr)
 	 * be invoked at splhigh().
 	 */
 	if (debugger == 0)
-	    wakeup((caddr_t)&sc->new_scp->smode);
+	    wakeup(&sc->new_scp->smode);
 	splx(s);
 	DPRINTF(5, ("switch done (new == old)\n"));
 	return 0;
@@ -2325,7 +2325,7 @@ sc_switch_scr(sc_softc_t *sc, u_int next_scr)
 
     /* wake up processes waiting for this vty */
     if (debugger == 0)
-	wakeup((caddr_t)&sc->cur_scp->smode);
+	wakeup(&sc->cur_scp->smode);
 
     /* wait for the controlling process to acknowledge, if necessary */
     if (signal_vt_acq(sc->cur_scp)) {
@@ -2351,7 +2351,7 @@ do_switch_scr(sc_softc_t *sc, int s)
     exchange_scr(sc);
     s = spltty();
     /* sc->cur_scp == sc->new_scp */
-    wakeup((caddr_t)&sc->cur_scp->smode);
+    wakeup(&sc->cur_scp->smode);
 
     /* wait for the controlling process to acknowledge, if necessary */
     if (!signal_vt_acq(sc->cur_scp)) {
diff --git a/sys/dev/usb/ulpt.c b/sys/dev/usb/ulpt.c
index 726669a..c4fd586 100644
--- a/sys/dev/usb/ulpt.c
+++ b/sys/dev/usb/ulpt.c
@@ -547,7 +547,7 @@ ulptopen(dev_t dev, int flag, int mode, usb_proc_ptr p)
 		}
 
 		/* wait 1/4 second, give up if we get a signal */
-		error = tsleep((caddr_t)sc, LPTPRI | PCATCH, "ulptop", STEP);
+		error = tsleep(sc, LPTPRI | PCATCH, "ulptop", STEP);
 		if (error != EWOULDBLOCK) {
 			sc->sc_state = 0;
 			goto done;
diff --git a/sys/dev/usb/usbdi_util.c b/sys/dev/usb/usbdi_util.c
index 1198049..f793e61 100644
--- a/sys/dev/usb/usbdi_util.c
+++ b/sys/dev/usb/usbdi_util.c
@@ -429,7 +429,7 @@ usbd_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
 		splx(s);
 		return (err);
 	}
-	error = tsleep((caddr_t)xfer, PZERO | PCATCH, lbl, 0);
+	error = tsleep(xfer, PZERO | PCATCH, lbl, 0);
 	splx(s);
 	if (error) {
 		DPRINTF(("usbd_bulk_transfer: tsleep=%d\n", error));
@@ -471,7 +471,7 @@ usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
 		splx(s);
 		return (err);
 	}
-	error = tsleep((caddr_t)xfer, PZERO | PCATCH, lbl, 0);
+	error = tsleep(xfer, PZERO | PCATCH, lbl, 0);
 	splx(s);
 	if (error) {
 		DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));