21 files changed, 151 insertions, 151 deletions

diff --git a/sys/dev/acpica/Osd/OsdSynch.c b/sys/dev/acpica/Osd/OsdSynch.c
index 79ae4f5..dacfc5c 100644
--- a/sys/dev/acpica/Osd/OsdSynch.c
+++ b/sys/dev/acpica/Osd/OsdSynch.c
@@ -139,7 +139,7 @@ AcpiOsWaitSemaphore(ACPI_HANDLE Handle, UINT32 Units, UINT32 Timeout)
 	    tmo = 1;
     }
 
-    mtx_enter(&as->as_mtx, MTX_DEF);
+    mtx_lock(&as->as_mtx);
     DEBUG_PRINT(TRACE_MUTEX, ("get %d units from semaphore %p (has %d), timeout %d\n",
 			      Units, as, as->as_units, Timeout));
     for (;;) {
@@ -163,7 +163,7 @@ AcpiOsWaitSemaphore(ACPI_HANDLE Handle, UINT32 Units, UINT32 Timeout)
 	    break;
 	}
     }
-    mtx_exit(&as->as_mtx, MTX_DEF);
+    mtx_unlock(&as->as_mtx);
 
     return_ACPI_STATUS(result);
 #else
@@ -182,14 +182,14 @@ AcpiOsSignalSemaphore(ACPI_HANDLE Handle, UINT32 Units)
     if (as == NULL)
 	return_ACPI_STATUS(AE_BAD_PARAMETER);
 
-    mtx_enter(&as->as_mtx, MTX_DEF);
+    mtx_lock(&as->as_mtx);
     DEBUG_PRINT(TRACE_MUTEX, ("return %d units to semaphore %p (has %d)\n",
 			      Units, as, as->as_units));
     as->as_units += Units;
     if (as->as_units > as->as_maxunits)
 	as->as_units = as->as_maxunits;
     wakeup(as);
-    mtx_exit(&as->as_mtx, MTX_DEF);
+    mtx_unlock(&as->as_mtx);
     return_ACPI_STATUS(AE_OK);
 #else
     return(AE_OK);
diff --git a/sys/dev/an/if_anreg.h b/sys/dev/an/if_anreg.h
index 9d67a3a..241cd65 100644
--- a/sys/dev/an/if_anreg.h
+++ b/sys/dev/an/if_anreg.h
@@ -844,8 +844,8 @@ struct an_softc	{
 	device_t		an_dev;
 };
 
-#define AN_LOCK(_sc)		mtx_enter(&(_sc)->an_mtx, MTX_DEF)
-#define AN_UNLOCK(_sc)		mtx_exit(&(_sc)->an_mtx, MTX_DEF)
+#define AN_LOCK(_sc)		mtx_lock(&(_sc)->an_mtx)
+#define AN_UNLOCK(_sc)		mtx_unlock(&(_sc)->an_mtx)
 
 void	an_release_resources	__P((device_t));
 int	an_alloc_port		__P((device_t, int, int));
diff --git a/sys/dev/dc/if_dcreg.h b/sys/dev/dc/if_dcreg.h
index 2327fa6..56f441f 100644
--- a/sys/dev/dc/if_dcreg.h
+++ b/sys/dev/dc/if_dcreg.h
@@ -702,8 +702,8 @@ struct dc_softc {
 };
 
 
-#define	DC_LOCK(_sc)		mtx_enter(&(_sc)->dc_mtx, MTX_DEF)
-#define	DC_UNLOCK(_sc)		mtx_exit(&(_sc)->dc_mtx, MTX_DEF)
+#define	DC_LOCK(_sc)		mtx_lock(&(_sc)->dc_mtx)
+#define	DC_UNLOCK(_sc)		mtx_unlock(&(_sc)->dc_mtx)
 
 #define DC_TX_POLL		0x00000001
 #define DC_TX_COALESCE		0x00000002
diff --git a/sys/dev/fxp/if_fxpvar.h b/sys/dev/fxp/if_fxpvar.h
index aee009c..7a9eb8d 100644
--- a/sys/dev/fxp/if_fxpvar.h
+++ b/sys/dev/fxp/if_fxpvar.h
@@ -86,5 +86,5 @@ struct fxp_softc {
 
 #define	sc_if			arpcom.ac_if
 #define	FXP_UNIT(_sc)		(_sc)->arpcom.ac_if.if_unit
-#define	FXP_LOCK(_sc)		mtx_enter(&(_sc)->sc_mtx, MTX_DEF)
-#define	FXP_UNLOCK(_sc)		mtx_exit(&(_sc)->sc_mtx, MTX_DEF)
+#define	FXP_LOCK(_sc)		mtx_lock(&(_sc)->sc_mtx)
+#define	FXP_UNLOCK(_sc)		mtx_unlock(&(_sc)->sc_mtx)
diff --git a/sys/dev/ichsmb/ichsmb.c b/sys/dev/ichsmb/ichsmb.c
index 9bbc7db..71b9b7a 100644
--- a/sys/dev/ichsmb/ichsmb.c
+++ b/sys/dev/ichsmb/ichsmb.c
@@ -167,7 +167,7 @@ ichsmb_quick(device_t dev, u_char slave, int how)
 	switch (how) {
 	case SMB_QREAD:
 	case SMB_QWRITE:
-		mtx_enter(&sc->mutex, MTX_DEF);
+		mtx_lock(&sc->mutex);
 		sc->ich_cmd = ICH_HST_CNT_SMB_CMD_QUICK;
 		bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 		    (slave << 1) | (how == SMB_QREAD ?
@@ -175,7 +175,7 @@ ichsmb_quick(device_t dev, u_char slave, int how)
 		bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
 		    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 		smb_error = ichsmb_wait(sc);
-		mtx_exit(&sc->mutex, MTX_DEF);
+		mtx_unlock(&sc->mutex);
 		break;
 	default:
 		smb_error = SMB_ENOTSUPP;
@@ -193,7 +193,7 @@ ichsmb_sendb(device_t dev, u_char slave, char byte)
 	DBG("slave=0x%02x byte=0x%02x\n", slave, (u_char)byte);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_WRITE);
@@ -201,7 +201,7 @@ ichsmb_sendb(device_t dev, u_char slave, char byte)
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	smb_error = ichsmb_wait(sc);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d\n", smb_error);
 	return (smb_error);
 }
@@ -215,7 +215,7 @@ ichsmb_recvb(device_t dev, u_char slave, char *byte)
 	DBG("slave=0x%02x\n", slave);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_READ);
@@ -223,7 +223,7 @@ ichsmb_recvb(device_t dev, u_char slave, char *byte)
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
 		*byte = bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_D0);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
 	return (smb_error);
 }
@@ -238,7 +238,7 @@ ichsmb_writeb(device_t dev, u_char slave, char cmd, char byte)
 	    slave, (u_char)cmd, (u_char)byte);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_WRITE);
@@ -247,7 +247,7 @@ ichsmb_writeb(device_t dev, u_char slave, char cmd, char byte)
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	smb_error = ichsmb_wait(sc);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d\n", smb_error);
 	return (smb_error);
 }
@@ -262,7 +262,7 @@ ichsmb_writew(device_t dev, u_char slave, char cmd, short word)
 	    slave, (u_char)cmd, (u_int16_t)word);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_WRITE);
@@ -272,7 +272,7 @@ ichsmb_writew(device_t dev, u_char slave, char cmd, short word)
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	smb_error = ichsmb_wait(sc);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d\n", smb_error);
 	return (smb_error);
 }
@@ -286,7 +286,7 @@ ichsmb_readb(device_t dev, u_char slave, char cmd, char *byte)
 	DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_READ);
@@ -295,7 +295,7 @@ ichsmb_readb(device_t dev, u_char slave, char cmd, char *byte)
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
 		*byte = bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_D0);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
 	return (smb_error);
 }
@@ -309,7 +309,7 @@ ichsmb_readw(device_t dev, u_char slave, char cmd, short *word)
 	DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_READ);
@@ -322,7 +322,7 @@ ichsmb_readw(device_t dev, u_char slave, char cmd, short *word)
 		  | (bus_space_read_1(sc->io_bst,
 			sc->io_bsh, ICH_D1) << 8);
 	}
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d word=0x%04x\n", smb_error, (u_int16_t)*word);
 	return (smb_error);
 }
@@ -337,7 +337,7 @@ ichsmb_pcall(device_t dev, u_char slave, char cmd, short sdata, short *rdata)
 	    slave, (u_char)cmd, (u_int16_t)sdata);
 	KASSERT(sc->ich_cmd == -1,
 	    ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_PROC_CALL;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_WRITE);
@@ -352,7 +352,7 @@ ichsmb_pcall(device_t dev, u_char slave, char cmd, short sdata, short *rdata)
 		  | (bus_space_read_1(sc->io_bst,
 			sc->io_bsh, ICH_D1) << 8);
 	}
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d rdata=0x%04x\n", smb_error, (u_int16_t)*rdata);
 	return (smb_error);
 }
@@ -388,7 +388,7 @@ ichsmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 	sc->block_index = 1;
 	sc->block_write = 1;
 
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_WRITE);
@@ -398,7 +398,7 @@ ichsmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	smb_error = ichsmb_wait(sc);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d\n", smb_error);
 	return (smb_error);
 }
@@ -419,7 +419,7 @@ ichsmb_bread(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 	sc->block_index = 0;
 	sc->block_write = 0;
 
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
 	bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
 	    (slave << 1) | ICH_XMIT_SLVA_READ);
@@ -429,7 +429,7 @@ ichsmb_bread(device_t dev, u_char slave, char cmd, u_char count, char *buf)
 	    ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
 	if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
 		bcopy(sc->block_data, buf, sc->block_count);
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 	DBG("smb_error=%d\n", smb_error);
 #if ICHSMB_DEBUG
 #define DISP(ch)	(((ch) < 0x20 || (ch) >= 0x7e) ? '.' : (ch))
@@ -491,7 +491,7 @@ ichsmb_device_intr(void *cookie)
 	int cmd_index;
         int count;
 
-	mtx_enter(&sc->mutex, MTX_DEF);
+	mtx_lock(&sc->mutex);
 	for (count = 0; count < maxloops; count++) {
 
 		/* Get and reset status bits */
@@ -603,7 +603,7 @@ finished:
 		/* Clear status bits and try again */
 		bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_STA, status);
 	}
-	mtx_exit(&sc->mutex, MTX_DEF);
+	mtx_unlock(&sc->mutex);
 
 	/* Too many loops? */
 	if (count == maxloops) {
diff --git a/sys/dev/isp/isp_freebsd.c b/sys/dev/isp/isp_freebsd.c
index ecf9e71..72fb71b 100644
--- a/sys/dev/isp/isp_freebsd.c
+++ b/sys/dev/isp/isp_freebsd.c
@@ -1992,9 +1992,9 @@ isp_done(struct ccb_scsiio *sccb)
 		XS_CMD_S_CLEAR(sccb);
 		ISP_UNLOCK(isp);
 #ifdef	ISP_SMPLOCK
-		mtx_enter(&Giant, MTX_DEF);
+		mtx_lock(&Giant);
 		xpt_done((union ccb *) sccb);
-		mtx_exit(&Giant, MTX_DEF);
+		mtx_unlock(&Giant);
 #else
 		xpt_done((union ccb *) sccb);
 #endif
diff --git a/sys/dev/isp/isp_freebsd.h b/sys/dev/isp/isp_freebsd.h
index 3bdfb1d..d184b7b 100644
--- a/sys/dev/isp/isp_freebsd.h
+++ b/sys/dev/isp/isp_freebsd.h
@@ -124,8 +124,8 @@ struct isposinfo {
  */
 
 #ifdef	ISP_SMPLOCK
-#define	ISP_LOCK(x)		mtx_enter(&(x)->isp_osinfo.lock, MTX_DEF)
-#define	ISP_UNLOCK(x)		mtx_exit(&(x)->isp_osinfo.lock, MTX_DEF)
+#define	ISP_LOCK(x)		mtx_lock(&(x)->isp_osinfo.lock)
+#define	ISP_UNLOCK(x)		mtx_unlock(&(x)->isp_osinfo.lock)
 #else
 #define	ISP_LOCK		isp_lock
 #define	ISP_UNLOCK		isp_unlock
diff --git a/sys/dev/pccbb/pccbb.c b/sys/dev/pccbb/pccbb.c
index b45b7ce..02cc697 100644
--- a/sys/dev/pccbb/pccbb.c
+++ b/sys/dev/pccbb/pccbb.c
@@ -530,13 +530,13 @@ pccbb_detach(device_t dev)
 	if (error > 0)
 		return ENXIO;
 
-	mtx_enter(&sc->sc_mtx, MTX_DEF);
+	mtx_lock(&sc->sc_mtx);
 	bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_intrhand);
 
 	sc->sc_flags |= PCCBB_KTHREAD_DONE;
 	if (sc->sc_flags & PCCBB_KTHREAD_RUNNING) {
 		wakeup(sc);
-		mtx_exit(&sc->sc_mtx, MTX_DEF);
+		mtx_unlock(&sc->sc_mtx);
 		DEVPRINTF((dev, "waiting for kthread exit..."));
 		error = tsleep(sc, PWAIT, "pccbb-detach-wait", 60 * hz);
 		if (error)
@@ -544,7 +544,7 @@ pccbb_detach(device_t dev)
 		else
 			DPRINTF(("done\n"));
 	} else
-		mtx_exit(&sc->sc_mtx, MTX_DEF);
+		mtx_unlock(&sc->sc_mtx);
 
 	bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
 	bus_release_resource(dev, SYS_RES_MEMORY, PCCBBR_SOCKBASE,
@@ -572,17 +572,17 @@ pccbb_driver_added(device_t dev, driver_t *driver)
 				sc->sc_cbdev = devlist[tmp];
 				if ((sc->sc_socketreg->socket_state
 				     & PCCBB_SOCKET_STAT_CD) == 0) {
-					mtx_enter(&sc->sc_mtx, MTX_DEF);
+					mtx_lock(&sc->sc_mtx);
 					wakeup(sc);
-					mtx_exit(&sc->sc_mtx, MTX_DEF);
+					mtx_unlock(&sc->sc_mtx);
 				}
 			} else if (strcmp(driver->name, "pccard") == 0) {
 				sc->sc_pccarddev = devlist[tmp];
 				if ((sc->sc_socketreg->socket_state
 				     & PCCBB_SOCKET_STAT_CD) == 0) {
-					mtx_enter(&sc->sc_mtx, MTX_DEF);
+					mtx_lock(&sc->sc_mtx);
 					wakeup(sc);
-					mtx_exit(&sc->sc_mtx, MTX_DEF);
+					mtx_unlock(&sc->sc_mtx);
 				}
 			} else
 				device_printf(dev,
@@ -616,7 +616,7 @@ pccbb_event_thread (void *arg)
 	struct pccbb_softc *sc = arg;
 	u_int32_t status;
 
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	for(;;) {
 		if (!(sc->sc_flags & PCCBB_KTHREAD_RUNNING))
 			sc->sc_flags |= PCCBB_KTHREAD_RUNNING;
@@ -629,7 +629,7 @@ pccbb_event_thread (void *arg)
 			 */
 			tsleep (&sc->sc_flags, PWAIT, "pccbbev", 1*hz);
 		}
-		mtx_enter(&sc->sc_mtx, MTX_DEF);
+		mtx_lock(&sc->sc_mtx);
 		if (sc->sc_flags & PCCBB_KTHREAD_DONE)
 			break;
 
@@ -639,9 +639,9 @@ pccbb_event_thread (void *arg)
 		} else {
 			pccbb_removal(sc);
 		}
-		mtx_exit(&sc->sc_mtx, MTX_DEF);
+		mtx_unlock(&sc->sc_mtx);
 	}
-	mtx_exit(&sc->sc_mtx, MTX_DEF);
+	mtx_unlock(&sc->sc_mtx);
 	sc->sc_flags &= ~PCCBB_KTHREAD_RUNNING;
 	wakeup(sc);
 	kthread_exit(0);
@@ -744,9 +744,9 @@ pccbb_intr(void* arg)
 	sc->sc_socketreg->socket_event = sockevent | 0x01;
 
 	if (sockevent & PCCBB_SOCKET_EVENT_CD) {
-		mtx_enter(&sc->sc_mtx, MTX_DEF);
+		mtx_lock(&sc->sc_mtx);
 		wakeup(sc);
-		mtx_exit(&sc->sc_mtx, MTX_DEF);
+		mtx_unlock(&sc->sc_mtx);
 	} else {
 		if (sockevent & PCCBB_SOCKET_EVENT_CSTS) {
 			DPRINTF((" cstsevent occures, 0x%08x\n",
diff --git a/sys/dev/random/harvest.c b/sys/dev/random/harvest.c
index 60067dc..93ce35b 100644
--- a/sys/dev/random/harvest.c
+++ b/sys/dev/random/harvest.c
@@ -123,7 +123,7 @@ void
 random_set_wakeup_exit(void *control)
 {
 	wakeup(control);
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	kthread_exit(0);
 	/* NOTREACHED */
 }
diff --git a/sys/dev/random/yarrow.c b/sys/dev/random/yarrow.c
index 816ab23..f1325e5 100644
--- a/sys/dev/random/yarrow.c
+++ b/sys/dev/random/yarrow.c
@@ -96,10 +96,10 @@ random_kthread(void *arg /* NOTUSED */)
 	struct source *source;
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("OWNERSHIP Giant == %d sched_lock == %d\n",
 		mtx_owned(&Giant), mtx_owned(&sched_lock));
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	for (pl = 0; pl < 2; pl++)
@@ -114,11 +114,11 @@ random_kthread(void *arg /* NOTUSED */)
 
 		else {
 #ifdef DEBUG1
-			mtx_enter(&Giant, MTX_DEF);
+			mtx_lock(&Giant);
 			printf("HARVEST src=%d bits=%d/%d pool=%d count=%lld\n",
 				event->source, event->bits, event->frac,
 				event->pool, event->somecounter);
-			mtx_exit(&Giant, MTX_DEF);
+			mtx_unlock(&Giant);
 #endif
 
 			/* Suck the harvested entropy out of the queue and hash
@@ -160,9 +160,9 @@ random_kthread(void *arg /* NOTUSED */)
 		/* Is the thread scheduled for a shutdown? */
 		if (random_kthread_control != 0) {
 #ifdef DEBUG
-			mtx_enter(&Giant, MTX_DEF);
+			mtx_lock(&Giant);
 			printf("Random kthread setting terminate\n");
-			mtx_exit(&Giant, MTX_DEF);
+			mtx_unlock(&Giant);
 #endif
 			random_set_wakeup_exit(&random_kthread_control);
 			/* NOTREACHED */
@@ -179,9 +179,9 @@ random_init(void)
 	int error;
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random initialise\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	/* This can be turned off by the very paranoid
@@ -213,9 +213,9 @@ random_init(void)
 	random_init_harvester(random_harvest_internal, read_random_real);
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random initialise finish\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	return 0;
@@ -225,31 +225,31 @@ void
 random_deinit(void)
 {
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random deinitialise\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	/* Deregister the randomness harvesting routine */
 	random_deinit_harvester();
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random deinitialise waiting for thread to terminate\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	/* Command the hash/reseed thread to end and wait for it to finish */
-	mtx_enter(&harvestring.lockout_mtx, MTX_DEF);
+	mtx_lock(&harvestring.lockout_mtx);
 	random_kthread_control = -1;
 	msleep((void *)&random_kthread_control, &harvestring.lockout_mtx, PUSER,
 		"rndend", 0);
-	mtx_exit(&harvestring.lockout_mtx, MTX_DEF);
+	mtx_unlock(&harvestring.lockout_mtx);
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random deinitialise removing mutexes\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	/* Remove the mutexes */
@@ -257,9 +257,9 @@ random_deinit(void)
 	mtx_destroy(&harvestring.lockout_mtx);
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random deinitialise finish\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 }
 
@@ -276,13 +276,13 @@ reseed(int fastslow)
 	int i, j;
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Reseed type %d\n", fastslow);
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	/* The reseed task must not be jumped on */
-	mtx_enter(&random_reseed_mtx, MTX_DEF);
+	mtx_lock(&random_reseed_mtx);
 
 	/* 1. Hash the accumulated entropy into v[0] */
 
@@ -353,12 +353,12 @@ reseed(int fastslow)
 	/* XXX Not done here yet */
 
 	/* Release the reseed mutex */
-	mtx_exit(&random_reseed_mtx, MTX_DEF);
+	mtx_unlock(&random_reseed_mtx);
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Reseed finish\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	if (!random_state.seeded) {
@@ -379,7 +379,7 @@ read_random_real(void *buf, u_int count)
 	u_int retval;
 
 	/* The reseed task must not be jumped on */
-	mtx_enter(&random_reseed_mtx, MTX_DEF);
+	mtx_lock(&random_reseed_mtx);
 
 	if (gate) {
 		generator_gate();
@@ -423,7 +423,7 @@ read_random_real(void *buf, u_int count)
 			cur -= retval;
 		}
 	}
-	mtx_exit(&random_reseed_mtx, MTX_DEF);
+	mtx_unlock(&random_reseed_mtx);
 	return retval;
 }
 
@@ -462,9 +462,9 @@ generator_gate(void)
 	u_char temp[KEYSIZE];
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Generator gate\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 
 	for (i = 0; i < KEYSIZE; i += sizeof(random_state.counter)) {
@@ -477,9 +477,9 @@ generator_gate(void)
 	memset((void *)temp, 0, KEYSIZE);
 
 #ifdef DEBUG
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Generator gate finish\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 }
 
@@ -495,16 +495,16 @@ random_harvest_internal(u_int64_t somecounter, void *entropy, u_int count,
 	int newhead, tail;
 
 #ifdef DEBUG1
-	mtx_enter(&Giant, MTX_DEF);
+	mtx_lock(&Giant);
 	printf("Random harvest\n");
-	mtx_exit(&Giant, MTX_DEF);
+	mtx_unlock(&Giant);
 #endif
 	if (origin < ENTROPYSOURCE) {
 
 		/* Add the harvested data to the ring buffer, but
 		 * do not block.
 		 */
-		if (mtx_try_enter(&harvestring.lockout_mtx, MTX_DEF)) {
+		if (mtx_trylock(&harvestring.lockout_mtx)) {
 
 			tail = atomic_load_acq_int(&harvestring.tail);
 			newhead = (harvestring.head + 1) % HARVEST_RING_SIZE;
@@ -533,7 +533,7 @@ random_harvest_internal(u_int64_t somecounter, void *entropy, u_int count,
 				wakeup(&harvestring.head);
 
 			}
-			mtx_exit(&harvestring.lockout_mtx, MTX_DEF);
+			mtx_unlock(&harvestring.lockout_mtx);
 
 		}
 
diff --git a/sys/dev/sf/if_sfreg.h b/sys/dev/sf/if_sfreg.h
index c2dc20e..fd2107f 100644
--- a/sys/dev/sf/if_sfreg.h
+++ b/sys/dev/sf/if_sfreg.h
@@ -1048,8 +1048,8 @@ struct sf_softc {
 };
 
 
-#define	SF_LOCK(_sc)		mtx_enter(&(_sc)->sf_mtx, MTX_DEF)
-#define	SF_UNLOCK(_sc)		mtx_exit(&(_sc)->sf_mtx, MTX_DEF)
+#define	SF_LOCK(_sc)		mtx_lock(&(_sc)->sf_mtx)
+#define	SF_UNLOCK(_sc)		mtx_unlock(&(_sc)->sf_mtx)
 
 #define SF_TIMEOUT	1000
 
diff --git a/sys/dev/sio/sio.c b/sys/dev/sio/sio.c
index 332ce49..be5f642 100644
--- a/sys/dev/sio/sio.c
+++ b/sys/dev/sio/sio.c
@@ -856,7 +856,7 @@ sioprobe(dev, xrid)
 	 * but mask them in the processor as well in case there are some
 	 * (misconfigured) shared interrupts.
 	 */
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 /* EXTRA DELAY? */
 
 	/*
@@ -953,7 +953,7 @@ sioprobe(dev, xrid)
 			CLR_FLAG(dev, COM_C_IIR_TXRDYBUG);
 		}
 		sio_setreg(com, com_cfcr, CFCR_8BITS);
-		mtx_exit(&sio_lock, MTX_SPIN);
+		mtx_unlock_spin(&sio_lock);
 		bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
 		return (iobase == siocniobase ? 0 : result);
 	}
@@ -993,7 +993,7 @@ sioprobe(dev, xrid)
 	irqmap[3] = isa_irq_pending();
 	failures[9] = (sio_getreg(com, com_iir) & IIR_IMASK) - IIR_NOPEND;
 
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 
 	irqs = irqmap[1] & ~irqmap[0];
 	if (bus_get_resource(idev, SYS_RES_IRQ, 0, &xirq, NULL) == 0 &&
@@ -1181,7 +1181,7 @@ sioattach(dev, xrid)
 	} else
 		com->it_in.c_ispeed = com->it_in.c_ospeed = TTYDEF_SPEED;
 	if (siosetwater(com, com->it_in.c_ispeed) != 0) {
-		mtx_exit(&sio_lock, MTX_SPIN);
+		mtx_unlock_spin(&sio_lock);
 		/*
 		 * Leave i/o resources allocated if this is a `cn'-level
 		 * console, so that other devices can't snarf them.
@@ -1190,7 +1190,7 @@ sioattach(dev, xrid)
 			bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
 		return (ENOMEM);
 	}
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	termioschars(&com->it_in);
 	com->it_out = com->it_in;
 
@@ -1485,7 +1485,7 @@ open_top:
 			}
 		}
 
-		mtx_enter(&sio_lock, MTX_SPIN);
+		mtx_lock_spin(&sio_lock);
 		(void) inb(com->line_status_port);
 		(void) inb(com->data_port);
 		com->prev_modem_status = com->last_modem_status
@@ -1497,7 +1497,7 @@ open_top:
 			outb(com->intr_ctl_port, IER_ERXRDY | IER_ETXRDY
 						| IER_ERLS | IER_EMSC);
 		}
-		mtx_exit(&sio_lock, MTX_SPIN);
+		mtx_unlock_spin(&sio_lock);
 		/*
 		 * Handle initial DCD.  Callout devices get a fake initial
 		 * DCD (trapdoor DCD).  If we are callout, then any sleeping
@@ -1753,7 +1753,7 @@ sioinput(com)
 			 * semantics instead of the save-and-disable semantics
 			 * that are used everywhere else.
 			 */
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			incc = com->iptr - buf;
 			if (tp->t_rawq.c_cc + incc > tp->t_ihiwat
 			    && (com->state & CS_RTS_IFLOW
@@ -1774,7 +1774,7 @@ sioinput(com)
 				tp->t_lflag &= ~FLUSHO;
 				comstart(tp);
 			}
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 		} while (buf < com->iptr);
 	} else {
 		do {
@@ -1783,7 +1783,7 @@ sioinput(com)
 			 * semantics instead of the save-and-disable semantics
 			 * that are used everywhere else.
 			 */
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			line_status = buf[com->ierroff];
 			recv_data = *buf++;
 			if (line_status
@@ -1798,7 +1798,7 @@ sioinput(com)
 					recv_data |= TTY_PE;
 			}
 			(*linesw[tp->t_line].l_rint)(recv_data, tp);
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 		} while (buf < com->iptr);
 	}
 	com_events -= (com->iptr - com->ibuf);
@@ -1823,9 +1823,9 @@ siointr(arg)
 #ifndef COM_MULTIPORT
 	com = (struct com_s *)arg;
 
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	siointr1(com);
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 #else /* COM_MULTIPORT */
 	bool_t		possibly_more_intrs;
 	int		unit;
@@ -1837,7 +1837,7 @@ siointr(arg)
 	 * devices, then the edge from one may be lost because another is
 	 * on.
 	 */
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	do {
 		possibly_more_intrs = FALSE;
 		for (unit = 0; unit < sio_numunits; ++unit) {
@@ -1856,7 +1856,7 @@ siointr(arg)
 			/* XXX COM_UNLOCK(); */
 		}
 	} while (possibly_more_intrs);
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 #endif /* COM_MULTIPORT */
 }
 
@@ -2264,7 +2264,7 @@ repeat:
 			 * Discard any events related to never-opened or
 			 * going-away devices.
 			 */
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			incc = com->iptr - com->ibuf;
 			com->iptr = com->ibuf;
 			if (com->state & CS_CHECKMSR) {
@@ -2272,33 +2272,33 @@ repeat:
 				com->state &= ~CS_CHECKMSR;
 			}
 			com_events -= incc;
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			continue;
 		}
 		if (com->iptr != com->ibuf) {
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			sioinput(com);
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 		}
 		if (com->state & CS_CHECKMSR) {
 			u_char	delta_modem_status;
 
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			delta_modem_status = com->last_modem_status
 					     ^ com->prev_modem_status;
 			com->prev_modem_status = com->last_modem_status;
 			com_events -= LOTS_OF_EVENTS;
 			com->state &= ~CS_CHECKMSR;
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			if (delta_modem_status & MSR_DCD)
 				(*linesw[tp->t_line].l_modem)
 					(tp, com->prev_modem_status & MSR_DCD);
 		}
 		if (com->state & CS_ODONE) {
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			com_events -= LOTS_OF_EVENTS;
 			com->state &= ~CS_ODONE;
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			if (!(com->state & CS_BUSY)
 			    && !(com->extra_state & CSE_BUSYCHECK)) {
 				timeout(siobusycheck, com, hz / 100);
@@ -2484,7 +2484,7 @@ comparam(tp, t)
 	if (com->state >= (CS_BUSY | CS_TTGO))
 		siointr1(com);
 
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	splx(s);
 	comstart(tp);
 	if (com->ibufold != NULL) {
@@ -2518,7 +2518,7 @@ siosetwater(com, speed)
 	for (ibufsize = 128; ibufsize < cp4ticks;)
 		ibufsize <<= 1;
 	if (ibufsize == com->ibufsize) {
-		mtx_enter(&sio_lock, MTX_SPIN);
+		mtx_lock_spin(&sio_lock);
 		return (0);
 	}
 
@@ -2528,7 +2528,7 @@ siosetwater(com, speed)
 	 */
 	ibuf = malloc(2 * ibufsize, M_DEVBUF, M_NOWAIT);
 	if (ibuf == NULL) {
-		mtx_enter(&sio_lock, MTX_SPIN);
+		mtx_lock_spin(&sio_lock);
 		return (ENOMEM);
 	}
 
@@ -2546,7 +2546,7 @@ siosetwater(com, speed)
 	 * Read current input buffer, if any.  Continue with interrupts
 	 * disabled.
 	 */
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	if (com->iptr != com->ibuf)
 		sioinput(com);
 
@@ -2581,7 +2581,7 @@ comstart(tp)
 	if (com == NULL)
 		return;
 	s = spltty();
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	if (tp->t_state & TS_TTSTOP)
 		com->state &= ~CS_TTGO;
 	else
@@ -2594,7 +2594,7 @@ comstart(tp)
 		    && com->state & CS_RTS_IFLOW)
 			outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
 	}
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
 		ttwwakeup(tp);
 		splx(s);
@@ -2610,7 +2610,7 @@ comstart(tp)
 						  sizeof com->obuf1);
 			com->obufs[0].l_next = NULL;
 			com->obufs[0].l_queued = TRUE;
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			if (com->state & CS_BUSY) {
 				qp = com->obufq.l_next;
 				while ((next = qp->l_next) != NULL)
@@ -2622,7 +2622,7 @@ comstart(tp)
 				com->obufq.l_next = &com->obufs[0];
 				com->state |= CS_BUSY;
 			}
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 		}
 		if (tp->t_outq.c_cc != 0 && !com->obufs[1].l_queued) {
 			com->obufs[1].l_tail
@@ -2630,7 +2630,7 @@ comstart(tp)
 						  sizeof com->obuf2);
 			com->obufs[1].l_next = NULL;
 			com->obufs[1].l_queued = TRUE;
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			if (com->state & CS_BUSY) {
 				qp = com->obufq.l_next;
 				while ((next = qp->l_next) != NULL)
@@ -2642,14 +2642,14 @@ comstart(tp)
 				com->obufq.l_next = &com->obufs[1];
 				com->state |= CS_BUSY;
 			}
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 		}
 		tp->t_state |= TS_BUSY;
 	}
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	if (com->state >= (CS_BUSY | CS_TTGO))
 		siointr1(com);	/* fake interrupt to start output */
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	ttwwakeup(tp);
 	splx(s);
 }
@@ -2664,7 +2664,7 @@ comstop(tp, rw)
 	com = com_addr(DEV_TO_UNIT(tp->t_dev));
 	if (com == NULL || com->gone)
 		return;
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	if (rw & FWRITE) {
 		if (com->hasfifo)
 #ifdef COM_ESP
@@ -2691,7 +2691,7 @@ comstop(tp, rw)
 		com_events -= (com->iptr - com->ibuf);
 		com->iptr = com->ibuf;
 	}
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	comstart(tp);
 }
 
@@ -2734,7 +2734,7 @@ commctl(com, bits, how)
 		mcr |= MCR_RTS;
 	if (com->gone)
 		return(0);
-	mtx_enter(&sio_lock, MTX_SPIN);
+	mtx_lock_spin(&sio_lock);
 	switch (how) {
 	case DMSET:
 		outb(com->modem_ctl_port,
@@ -2747,7 +2747,7 @@ commctl(com, bits, how)
 		outb(com->modem_ctl_port, com->mcr_image &= ~mcr);
 		break;
 	}
-	mtx_exit(&sio_lock, MTX_SPIN);
+	mtx_unlock_spin(&sio_lock);
 	return (0);
 }
 
@@ -2806,9 +2806,9 @@ comwakeup(chan)
 		com = com_addr(unit);
 		if (com != NULL && !com->gone
 		    && (com->state >= (CS_BUSY | CS_TTGO) || com->poll)) {
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			siointr1(com);
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 		}
 	}
 
@@ -2830,10 +2830,10 @@ comwakeup(chan)
 			u_int	delta;
 			u_long	total;
 
-			mtx_enter(&sio_lock, MTX_SPIN);
+			mtx_lock_spin(&sio_lock);
 			delta = com->delta_error_counts[errnum];
 			com->delta_error_counts[errnum] = 0;
-			mtx_exit(&sio_lock, MTX_SPIN);
+			mtx_unlock_spin(&sio_lock);
 			if (delta == 0)
 				continue;
 			total = com->error_counts[errnum] += delta;
diff --git a/sys/dev/sk/if_skreg.h b/sys/dev/sk/if_skreg.h
index 6f31d1d..061707c 100644
--- a/sys/dev/sk/if_skreg.h
+++ b/sys/dev/sk/if_skreg.h
@@ -1182,10 +1182,10 @@ struct sk_softc {
 	struct mtx		sk_mtx;
 };
 
-#define	SK_LOCK(_sc)		mtx_enter(&(_sc)->sk_mtx, MTX_DEF)
-#define	SK_UNLOCK(_sc)		mtx_exit(&(_sc)->sk_mtx, MTX_DEF)
-#define	SK_IF_LOCK(_sc)		mtx_enter(&(_sc)->sk_softc->sk_mtx, MTX_DEF)
-#define	SK_IF_UNLOCK(_sc)	mtx_exit(&(_sc)->sk_softc->sk_mtx, MTX_DEF)
+#define	SK_LOCK(_sc)		mtx_lock(&(_sc)->sk_mtx)
+#define	SK_UNLOCK(_sc)		mtx_unlock(&(_sc)->sk_mtx)
+#define	SK_IF_LOCK(_sc)		mtx_lock(&(_sc)->sk_softc->sk_mtx)
+#define	SK_IF_UNLOCK(_sc)	mtx_unlock(&(_sc)->sk_softc->sk_mtx)
 
 /* Softc for each logical interface */
 struct sk_if_softc {
diff --git a/sys/dev/ti/if_tireg.h b/sys/dev/ti/if_tireg.h
index 0eaff14..df399be 100644
--- a/sys/dev/ti/if_tireg.h
+++ b/sys/dev/ti/if_tireg.h
@@ -1147,8 +1147,8 @@ struct ti_softc {
 	struct mtx		ti_mtx;
 };
 
-#define	TI_LOCK(_sc)		mtx_enter(&(_sc)->ti_mtx, MTX_DEF)
-#define	TI_UNLOCK(_sc)		mtx_exit(&(_sc)->ti_mtx, MTX_DEF)
+#define	TI_LOCK(_sc)		mtx_lock(&(_sc)->ti_mtx)
+#define	TI_UNLOCK(_sc)		mtx_unlock(&(_sc)->ti_mtx)
 
 /*
  * Microchip Technology 24Cxx EEPROM control bytes
diff --git a/sys/dev/usb/if_auereg.h b/sys/dev/usb/if_auereg.h
index 5558b50..5544091 100644
--- a/sys/dev/usb/if_auereg.h
+++ b/sys/dev/usb/if_auereg.h
@@ -249,8 +249,8 @@ struct aue_softc {
 	struct mtx		aue_mtx;
 };
 
-#define	AUE_LOCK(_sc)		mtx_enter(&(_sc)->aue_mtx, MTX_DEF)
-#define	AUE_UNLOCK(_sc)		mtx_exit(&(_sc)->aue_mtx, MTX_DEF)
+#define	AUE_LOCK(_sc)		mtx_lock(&(_sc)->aue_mtx)
+#define	AUE_UNLOCK(_sc)		mtx_unlock(&(_sc)->aue_mtx)
 
 #define AUE_TIMEOUT		1000
 #define ETHER_ALIGN		2
diff --git a/sys/dev/usb/if_cuereg.h b/sys/dev/usb/if_cuereg.h
index 5d043e4..dc7b8c8 100644
--- a/sys/dev/usb/if_cuereg.h
+++ b/sys/dev/usb/if_cuereg.h
@@ -182,5 +182,5 @@ struct cue_softc {
 	struct mtx		cue_mtx;
 };
 
-#define	CUE_LOCK(_sc)		mtx_enter(&(_sc)->cue_mtx, MTX_DEF)
-#define	CUE_UNLOCK(_sc)		mtx_exit(&(_sc)->cue_mtx, MTX_DEF)
+#define	CUE_LOCK(_sc)		mtx_lock(&(_sc)->cue_mtx)
+#define	CUE_UNLOCK(_sc)		mtx_unlock(&(_sc)->cue_mtx)
diff --git a/sys/dev/usb/if_kuereg.h b/sys/dev/usb/if_kuereg.h
index 49cd235..b5ffb32 100644
--- a/sys/dev/usb/if_kuereg.h
+++ b/sys/dev/usb/if_kuereg.h
@@ -173,5 +173,5 @@ struct kue_softc {
 	struct mtx		kue_mtx;
 };
 
-#define	KUE_LOCK(_sc)		mtx_enter(&(_sc)->kue_mtx, MTX_DEF)
-#define	KUE_UNLOCK(_sc)		mtx_exit(&(_sc)->kue_mtx, MTX_DEF)
+#define	KUE_LOCK(_sc)		mtx_lock(&(_sc)->kue_mtx)
+#define	KUE_UNLOCK(_sc)		mtx_unlock(&(_sc)->kue_mtx)
diff --git a/sys/dev/vinum/vinumdaemon.c b/sys/dev/vinum/vinumdaemon.c
index 99c1751..f03d36b 100644
--- a/sys/dev/vinum/vinumdaemon.c
+++ b/sys/dev/vinum/vinumdaemon.c
@@ -72,9 +72,9 @@ vinum_daemon(void)
     PROC_LOCK(curproc);
     curproc->p_flag |= P_SYSTEM;			    /* we're a system process */
     PROC_UNLOCK(curproc);
-    mtx_enter(&sched_lock, MTX_SPIN);
+    mtx_lock_spin(&sched_lock);
     curproc->p_sflag |= PS_INMEM;
-    mtx_exit(&sched_lock, MTX_SPIN);
+    mtx_unlock_spin(&sched_lock);
     daemon_save_config();				    /* start by saving the configuration */
     daemonpid = curproc->p_pid;				    /* mark our territory */
     while (1) {
diff --git a/sys/dev/vinum/vinumlock.c b/sys/dev/vinum/vinumlock.c
index c85fbae..801f13f 100644
--- a/sys/dev/vinum/vinumlock.c
+++ b/sys/dev/vinum/vinumlock.c
@@ -132,7 +132,7 @@ lockrange(daddr_t stripe, struct buf *bp, struct plex *plex)
      * increment all addresses by 1.
      */
     stripe++;
-    mtx_enter(&plex->lockmtx, MTX_DEF);
+    mtx_lock(&plex->lockmtx);
 
     /* Wait here if the table is full */
     while (plex->usedlocks == PLEX_LOCKS)		    /* all in use */
@@ -187,7 +187,7 @@ lockrange(daddr_t stripe, struct buf *bp, struct plex *plex)
     pos->stripe = stripe;
     pos->bp = bp;
     plex->usedlocks++;					    /* one more lock */
-    mtx_exit(&plex->lockmtx, MTX_DEF);
+    mtx_unlock(&plex->lockmtx);
 #ifdef VINUMDEBUG
     if (debug & DEBUG_LASTREQS)
 	logrq(loginfo_lock, (union rqinfou) pos, bp);
diff --git a/sys/dev/vr/if_vrreg.h b/sys/dev/vr/if_vrreg.h
index 8217a8c..235962d 100644
--- a/sys/dev/vr/if_vrreg.h
+++ b/sys/dev/vr/if_vrreg.h
@@ -414,8 +414,8 @@ struct vr_softc {
 	struct mtx		vr_mtx;
 };
 
-#define	VR_LOCK(_sc)		mtx_enter(&(_sc)->vr_mtx, MTX_DEF)
-#define	VR_UNLOCK(_sc)		mtx_exit(&(_sc)->vr_mtx, MTX_DEF)
+#define	VR_LOCK(_sc)		mtx_lock(&(_sc)->vr_mtx)
+#define	VR_UNLOCK(_sc)		mtx_unlock(&(_sc)->vr_mtx)
 
 /*
  * register space access macros
diff --git a/sys/dev/wi/if_wireg.h b/sys/dev/wi/if_wireg.h
index eb4ab7c..9751029 100644
--- a/sys/dev/wi/if_wireg.h
+++ b/sys/dev/wi/if_wireg.h
@@ -128,8 +128,8 @@ struct wi_softc	{
 	int			wi_prism2;	/* set to 1 if it uses a Prism II chip */
 };
 
-#define	WI_LOCK(_sc)		mtx_enter(&(_sc)->wi_mtx, MTX_DEF)
-#define	WI_UNLOCK(_sc)		mtx_exit(&(_sc)->wi_mtx, MTX_DEF)
+#define	WI_LOCK(_sc)		mtx_lock(&(_sc)->wi_mtx)
+#define	WI_UNLOCK(_sc)		mtx_unlock(&(_sc)->wi_mtx)
 
 #define WI_TIMEOUT	65536