sound: Retire snd_mtx* wrappers

Do not create mutexes with snd_mtxcreate(). It doesn't provide any
value, plus it first allocates the mutex with malloc(9). Allocate
mutexes in the stack and use mtx_* functions directly instead of the
snd_mtx* wrappers.

Sponsored by:	The FreeBSD Foundation
MFC after:	1 week
Reviewed by:	kib, markj
Differential Revision:	https://reviews.freebsd.org/D53855

sys/arm/allwinner/a10_codec.c

@@ -159,7 +159,7 @@ struct a10codec_chinfo {
 struct a10codec_info {
 	device_t		dev;
 	struct resource		*res[2];
-	struct mtx		*lock;
+	struct mtx		lock;
 	bus_dma_tag_t		dmat;
 	unsigned		dmasize;
 	void			*ih;
@@ -949,7 +949,7 @@ a10codec_chan_trigger(kobj_t obj, void *data, int go)
 	if (!PCMTRIG_COMMON(go))
 		return (0);
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch (go) {
 	case PCMTRIG_START:
 		ch->run = 1;
@@ -964,7 +964,7 @@ a10codec_chan_trigger(kobj_t obj, void *data, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -1075,7 +1075,7 @@ a10codec_attach(device_t dev)
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 	sc->cfg = (void *)ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 	sc->dev = dev;
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "a10codec softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "a10codec_softc", MTX_DEF);
 
 	if (bus_alloc_resources(dev, a10codec_spec, sc->res)) {
 		device_printf(dev, "cannot allocate resources for device\n");
@@ -1180,7 +1180,7 @@ a10codec_attach(device_t dev)
 
 fail:
 	bus_release_resources(dev, a10codec_spec, sc->res);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_DEVBUF);
 
 	return (ENXIO);

sys/arm/freescale/imx/imx6_ssi.c

@@ -173,7 +173,7 @@ struct sc_info {
 	bus_space_tag_t		bst;
 	bus_space_handle_t	bsh;
 	device_t		dev;
-	struct mtx		*lock;
+	struct mtx		lock;
 	void			*ih;
 	int			pos;
 	int			dma_size;
@@ -242,10 +242,10 @@ ssimixer_init(struct snd_mixer *m)
 	mask = SOUND_MASK_PCM;
 	mask |= SOUND_MASK_VOLUME;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 	mix_setdevs(m, mask);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -290,14 +290,14 @@ ssichan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	scp = (struct sc_pcminfo *)devinfo;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ch = &scp->chan[0];
 	ch->dir = dir;
 	ch->run = 0;
 	ch->buffer = b;
 	ch->channel = c;
 	ch->parent = scp;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	if (sndbuf_setup(ch->buffer, sc->buf_base, sc->dma_size) != 0) {
 		device_printf(scp->dev, "Can't setup sndbuf.\n");
@@ -318,9 +318,9 @@ ssichan_free(kobj_t obj, void *data)
 	device_printf(scp->dev, "ssichan_free()\n");
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	/* TODO: free channel buffer */
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -565,7 +565,7 @@ ssichan_trigger(kobj_t obj, void *data, int go)
 	scp = ch->parent;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	switch (go) {
 	case PCMTRIG_START:
@@ -590,7 +590,7 @@ ssichan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -736,7 +736,7 @@ ssi_attach(device_t dev)
 	sc->pos = 0;
 	sc->conf = malloc(sizeof(struct sdma_conf), M_DEVBUF, M_WAITOK | M_ZERO);
 
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "ssi softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "ssi softc");
 	if (sc->lock == NULL) {
 		device_printf(dev, "Can't create mtx\n");
 		return (ENXIO);

sys/arm/freescale/vybrid/vf_sai.c

@@ -138,7 +138,7 @@ struct sc_info {
 	bus_space_tag_t		bst;
 	bus_space_handle_t	bsh;
 	device_t		dev;
-	struct mtx		*lock;
+	struct mtx		lock;
 	uint32_t		speed;
 	uint32_t		period;
 	void			*ih;
@@ -206,10 +206,10 @@ saimixer_init(struct snd_mixer *m)
 
 	mask = SOUND_MASK_PCM;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 	mix_setdevs(m, mask);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -252,14 +252,14 @@ saichan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	scp = (struct sc_pcminfo *)devinfo;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ch = &scp->chan[0];
 	ch->dir = dir;
 	ch->run = 0;
 	ch->buffer = b;
 	ch->channel = c;
 	ch->parent = scp;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	if (sndbuf_setup(ch->buffer, sc->buf_base, sc->dma_size) != 0) {
 		device_printf(scp->dev, "Can't setup sndbuf.\n");
@@ -280,9 +280,9 @@ saichan_free(kobj_t obj, void *data)
 	device_printf(scp->dev, "saichan_free()\n");
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	/* TODO: free channel buffer */
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -513,7 +513,7 @@ saichan_trigger(kobj_t obj, void *data, int go)
 	struct sc_pcminfo *scp = ch->parent;
 	struct sc_info *sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	switch (go) {
 	case PCMTRIG_START:
@@ -532,7 +532,7 @@ saichan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -691,7 +691,7 @@ sai_attach(device_t dev)
 	sc->sr = &rate_map[0];
 	sc->pos = 0;
 
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "sai softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "sai softc");
 	if (sc->lock == NULL) {
 		device_printf(dev, "Cant create mtx\n");
 		return (ENXIO);

sys/dev/sound/dummy.c

@@ -64,7 +64,7 @@ struct dummy_softc {
 	int chnum;
 	struct dummy_chan chans[DUMMY_NCHAN];
 	struct callout callout;
-	struct mtx *lock;
+	struct mtx lock;
 	bool stopped;
 };
 
@@ -74,7 +74,7 @@ dummy_active(struct dummy_softc *sc)
 	struct dummy_chan *ch;
 	int i;
 
-	snd_mtxassert(sc->lock);
+	mtx_assert(&sc->lock, MA_OWNED);
 
 	for (i = 0; i < sc->chnum; i++) {
 		ch = &sc->chans[i];
@@ -109,9 +109,9 @@ dummy_chan_io(void *arg)
 			ch->ptr %= ch->buf->bufsize;
 		} else
 			sndbuf_fillsilence(ch->buf);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		chn_intr(ch->chan);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 	}
 	if (!sc->stopped)
 		callout_schedule(&sc->callout, 1);
@@ -141,7 +141,7 @@ dummy_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 
 	sc = devinfo;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	ch = &sc->chans[sc->chnum++];
 	ch->sc = sc;
@@ -150,7 +150,7 @@ dummy_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	ch->buf = b;
 	ch->caps = &sc->caps;
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	bufsz = pcm_getbuffersize(sc->dev, 2048, 2048, 65536);
 	buf = malloc(bufsz, M_DEVBUF, M_WAITOK | M_ZERO);
@@ -199,10 +199,10 @@ dummy_chan_trigger(kobj_t obj, void *data, int go)
 	struct dummy_chan *ch = data;
 	struct dummy_softc *sc = ch->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	if (sc->stopped) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return (0);
 	}
 
@@ -222,7 +222,7 @@ dummy_chan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -320,8 +320,9 @@ dummy_attach(device_t dev)
 
 	sc = device_get_softc(dev);
 	sc->dev = dev;
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_dummy softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_dummy softc",
-	callout_init_mtx(&sc->callout, sc->lock, 0);
+	    MTX_DEF);
+	callout_init_mtx(&sc->callout, &sc->lock, 0);
 
 	sc->cap_fmts[0] = SND_FORMAT(AFMT_S32_LE, 2, 0);
 	sc->cap_fmts[1] = SND_FORMAT(AFMT_S24_LE, 2, 0);
@@ -362,12 +363,12 @@ dummy_detach(device_t dev)
 	struct dummy_softc *sc = device_get_softc(dev);
 	int err;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->stopped = true;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	callout_drain(&sc->callout);
 	err = pcm_unregister(dev);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 
 	return (err);
 }

sys/dev/sound/pci/als4000.c

@@ -79,7 +79,7 @@ struct sc_info {
 	struct resource		*reg, *irq;
 	int			regid, irqid;
 	void			*ih;
-	struct mtx		*lock;
+	struct mtx		lock;
 
 	unsigned int		bufsz;
 	struct sc_chinfo	pch, rch;
@@ -208,7 +208,7 @@ alschan_init(kobj_t obj, void *devinfo,
 	struct	sc_info	*sc = devinfo;
 	struct	sc_chinfo *ch;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (dir == PCMDIR_PLAY) {
 		ch = &sc->pch;
 		ch->gcr_fifo_status = ALS_GCR_FIFO0_STATUS;
@@ -223,7 +223,7 @@ alschan_init(kobj_t obj, void *devinfo,
 	ch->format = SND_FORMAT(AFMT_U8, 1, 0);
 	ch->speed = 8000;
 	ch->buffer = b;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0)
 		return NULL;
@@ -278,9 +278,9 @@ alschan_getptr(kobj_t obj, void *data)
 	struct sc_info *sc = ch->parent;
 	int32_t pos, sz;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	pos = als_gcr_rd(ch->parent, ch->gcr_fifo_status) & 0xffff;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	sz  = ch->buffer->bufsize;
 	return (2 * sz - pos - 1) % sz;
 }
@@ -397,7 +397,7 @@ alspchan_trigger(kobj_t obj, void *data, int go)
 	if (!PCMTRIG_COMMON(go))
 		return 0;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch(go) {
 	case PCMTRIG_START:
 		als_playback_start(ch);
@@ -409,7 +409,7 @@ alspchan_trigger(kobj_t obj, void *data, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -493,7 +493,7 @@ alsrchan_trigger(kobj_t obj, void *data, int go)
 	struct	sc_chinfo *ch = data;
 	struct sc_info *sc = ch->parent;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch(go) {
 	case PCMTRIG_START:
 		als_capture_start(ch);
@@ -503,7 +503,7 @@ alsrchan_trigger(kobj_t obj, void *data, int go)
 		als_capture_stop(ch);
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -637,19 +637,19 @@ als_intr(void *p)
 	struct sc_info *sc = (struct sc_info *)p;
 	u_int8_t intr, sb_status;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	intr = als_intr_rd(sc);
 
 	if (intr & 0x80) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		chn_intr(sc->pch.channel);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 	}
 
 	if (intr & 0x40) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		chn_intr(sc->rch.channel);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 	}
 
 	/* ACK interrupt in PCI core */
@@ -667,7 +667,7 @@ als_intr(void *p)
 	if (sb_status & ALS_IRQ_CR1E)
 		als_ack_read(sc, ALS_CR1E_ACK_PORT);
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return;
 }
 
@@ -749,10 +749,7 @@ als_resource_free(device_t dev, struct sc_info *sc)
 		bus_dma_tag_destroy(sc->parent_dmat);
 		sc->parent_dmat = 0;
 	}
-	if (sc->lock) {
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
-		sc->lock = NULL;
-	}
 }
 
 static int
@@ -808,7 +805,8 @@ als_pci_attach(device_t dev)
 	char status[SND_STATUSLEN];
 
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_als4000 softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_als4000 softc",
+	    MTX_DEF);
 	sc->dev = dev;
 
 	pci_enable_busmaster(dev);
@@ -882,11 +880,11 @@ als_pci_suspend(device_t dev)
 {
 	struct sc_info *sc = pcm_getdevinfo(dev);
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->pch.dma_was_active = als_playback_stop(&sc->pch);
 	sc->rch.dma_was_active = als_capture_stop(&sc->rch);
 	als_uninit(sc);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -895,16 +893,16 @@ als_pci_resume(device_t dev)
 {
 	struct sc_info *sc = pcm_getdevinfo(dev);
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (als_init(sc) != 0) {
 		device_printf(dev, "unable to reinitialize the card\n");
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return ENXIO;
 	}
 
 	if (mixer_reinit(dev) != 0) {
 		device_printf(dev, "unable to reinitialize the mixer\n");
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return ENXIO;
 	}
 
@@ -915,7 +913,7 @@ als_pci_resume(device_t dev)
 	if (sc->rch.dma_was_active) {
 		als_capture_start(&sc->rch);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }

sys/dev/sound/pci/atiixp.c

@@ -129,7 +129,7 @@ struct atiixp_info {
 	uint32_t blkcnt;
 	int registered_channels;
 
-	struct mtx *lock;
+	struct mtx lock;
 	struct callout poll_timer;
 	int poll_ticks, polling;
 };
@@ -139,9 +139,9 @@ struct atiixp_info {
 #define atiixp_wr(_sc, _reg, _val)	\
 		bus_space_write_4((_sc)->st, (_sc)->sh, _reg, _val)
 
-#define atiixp_lock(_sc)	snd_mtxlock((_sc)->lock)
+#define atiixp_lock(_sc)	mtx_lock(&(_sc)->lock)
-#define atiixp_unlock(_sc)	snd_mtxunlock((_sc)->lock)
+#define atiixp_unlock(_sc)	mtx_unlock(&(_sc)->lock)
-#define atiixp_assert(_sc)	snd_mtxassert((_sc)->lock)
+#define atiixp_assert(_sc)	mtx_assert(&(_sc)->lock, MA_OWNED)
 
 static uint32_t atiixp_fmt_32bit[] = {
 	SND_FORMAT(AFMT_S16_LE, 2, 0),
@@ -1019,7 +1019,7 @@ atiixp_chip_post_init(void *arg)
 	if (sc->codec_not_ready_bits == 0) {
 		/* wait for the interrupts to happen */
 		do {
-			msleep(sc, sc->lock, PWAIT, "ixpslp", max(hz / 10, 1));
+			msleep(sc, &sc->lock, PWAIT, "ixpslp", max(hz / 10, 1));
 			if (sc->codec_not_ready_bits != 0)
 				break;
 		} while (--timeout);
@@ -1157,10 +1157,7 @@ atiixp_release_resource(struct atiixp_info *sc)
 		bus_dma_tag_destroy(sc->sgd_dmat);
 		sc->sgd_dmat = NULL;
 	}
-	if (sc->lock) {
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
-		sc->lock = NULL;
-	}
 	free(sc, M_DEVBUF);
 }
 
@@ -1190,7 +1187,8 @@ atiixp_pci_attach(device_t dev)
 	int i;
 
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_atiixp softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_atiixp softc",
+	    MTX_DEF);
 	sc->dev = dev;
 
 	callout_init(&sc->poll_timer, 1);

sys/dev/sound/pci/cmi.c

@@ -116,7 +116,7 @@ struct sc_info {
 	struct resource		*reg, *irq;
 	int			regid, irqid;
 	void 			*ih;
-	struct mtx		*lock;
+	struct mtx		lock;
 
 	int			spdif_enabled;
 	unsigned int		bufsz;
@@ -361,13 +361,13 @@ cmichan_init(kobj_t obj, void *devinfo,
 	}
 
 	ch->dir = dir;
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		cmi_dma_prog(sc, ch, CMPCI_REG_DMA0_BASE);
 	} else {
 		cmi_dma_prog(sc, ch, CMPCI_REG_DMA1_BASE);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return ch;
 }
@@ -394,7 +394,7 @@ cmichan_setformat(kobj_t obj, void *data, u_int32_t format)
 		f |= CMPCI_REG_FORMAT_MONO;
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		cmi_partial_wr4(ch->parent,
 				CMPCI_REG_CHANNEL_FORMAT,
@@ -408,7 +408,7 @@ cmichan_setformat(kobj_t obj, void *data, u_int32_t format)
 				CMPCI_REG_CH1_FORMAT_MASK,
 				f);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	ch->fmt = format;
 
 	return 0;
@@ -422,7 +422,7 @@ cmichan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 	u_int32_t r, rsp __unused;
 
 	r = cmpci_rate_to_regvalue(speed);
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		if (speed < 44100) {
 			/* disable if req before rate change */
@@ -450,7 +450,7 @@ cmichan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 		rsp >>= CMPCI_REG_ADC_FS_SHIFT;
 		rsp &= 	CMPCI_REG_ADC_FS_MASK;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	ch->spd = cmpci_regvalue_to_rate(r);
 
 	DEB(printf("cmichan_setspeed (%s) %d -> %d (%d)\n",
@@ -484,7 +484,7 @@ cmichan_trigger(kobj_t obj, void *data, int go)
 	if (!PCMTRIG_COMMON(go))
 		return 0;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		switch(go) {
 		case PCMTRIG_START:
@@ -506,7 +506,7 @@ cmichan_trigger(kobj_t obj, void *data, int go)
 			break;
 		}
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -517,13 +517,13 @@ cmichan_getptr(kobj_t obj, void *data)
 	struct sc_info		*sc = ch->parent;
 	u_int32_t physptr, bufptr, sz;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		physptr = cmi_rd(sc, CMPCI_REG_DMA0_BASE, 4);
 	} else {
 		physptr = cmi_rd(sc, CMPCI_REG_DMA1_BASE, 4);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	sz = ch->buffer->bufsize;
 	bufptr = (physptr - ch->phys_buf + sz - ch->bps) % sz;
@@ -538,7 +538,7 @@ cmi_intr(void *data)
 	u_int32_t intrstat;
 	u_int32_t toclear;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	intrstat = cmi_rd(sc, CMPCI_REG_INTR_STATUS, 4);
 	if ((intrstat & CMPCI_REG_ANY_INTR) != 0) {
 		toclear = 0;
@@ -554,7 +554,7 @@ cmi_intr(void *data)
 
 		if (toclear) {
 			cmi_clr4(sc, CMPCI_REG_INTR_CTRL, toclear);
-			snd_mtxunlock(sc->lock);
+			mtx_unlock(&sc->lock);
 
 			/* Signal interrupts to channel */
 			if (intrstat & CMPCI_REG_CH0_INTR) {
@@ -565,14 +565,14 @@ cmi_intr(void *data)
 				chn_intr(sc->rch.channel);
 			}
 
-			snd_mtxlock(sc->lock);
+			mtx_lock(&sc->lock);
 			cmi_set4(sc, CMPCI_REG_INTR_CTRL, toclear);
 		}
 	}
 	if(sc->mpu_intr) {
 		(sc->mpu_intr)(sc->mpu);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return;
 }
 
@@ -799,10 +799,10 @@ cmi_muninit(struct mpu401 *arg, void *cookie)
 {
 	struct sc_info *sc = cookie;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->mpu_intr = NULL;
 	sc->mpu = NULL;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -933,7 +933,8 @@ cmi_attach(device_t dev)
 	char			status[SND_STATUSLEN];
 
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_cmi softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_cmi softc",
+	    MTX_DEF);
 	pci_enable_busmaster(dev);
 
 	sc->dev = dev;
@@ -1007,8 +1008,7 @@ cmi_attach(device_t dev)
 		bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq);
 	if (sc->reg)
 		bus_release_resource(dev, SYS_RES_IOPORT, sc->regid, sc->reg);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 	if (sc)
 		free(sc, M_DEVBUF);
 
@@ -1037,7 +1037,7 @@ cmi_detach(device_t dev)
 	if (sc->mpu_reg)
 	    bus_release_resource(dev, SYS_RES_IOPORT, sc->mpu_regid, sc->mpu_reg);
 
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_DEVBUF);
 
 	return 0;
@@ -1048,11 +1048,11 @@ cmi_suspend(device_t dev)
 {
 	struct sc_info *sc = pcm_getdevinfo(dev);
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->pch.dma_was_active = cmi_ch0_stop(sc, &sc->pch);
 	sc->rch.dma_was_active = cmi_ch1_stop(sc, &sc->rch);
 	cmi_power(sc, 3);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -1061,17 +1061,17 @@ cmi_resume(device_t dev)
 {
 	struct sc_info *sc = pcm_getdevinfo(dev);
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	cmi_power(sc, 0);
 	if (cmi_init(sc) != 0) {
 		device_printf(dev, "unable to reinitialize the card\n");
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return ENXIO;
 	}
 
 	if (mixer_reinit(dev) == -1) {
 		device_printf(dev, "unable to reinitialize the mixer\n");
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
                 return ENXIO;
         }
 
@@ -1086,7 +1086,7 @@ cmi_resume(device_t dev)
 		cmichan_setformat(NULL, &sc->rch, sc->rch.fmt);
 		cmi_ch1_start(sc, &sc->rch);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 

sys/dev/sound/pci/emu10k1.c

@@ -218,7 +218,7 @@ struct sc_info {
 
 	struct resource *reg, *irq;
 	void		*ih;
-	struct mtx	*lock;
+	struct mtx	lock;
 
 	unsigned int bufsz;
 	int timer, timerinterval;
@@ -820,10 +820,10 @@ emupchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	ch->blksz = sc->bufsz / 2;
 	ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
 	ch->spd = 8000;
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ch->master = emu_valloc(sc);
 	ch->slave = emu_valloc(sc);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	r = (emu_vinit(sc, ch->master, ch->slave, sc->bufsz, ch->buffer))
 	    ? NULL : ch;
 
@@ -837,9 +837,9 @@ emupchan_free(kobj_t obj, void *data)
 	struct sc_info *sc = ch->parent;
 	int r;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	r = emu_memfree(sc, ch->buffer->buf);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return r;
 }
@@ -869,9 +869,9 @@ emupchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 	struct sc_info *sc = ch->parent;
 
 	ch->blksz = blocksize;
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	emu_settimer(sc);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return blocksize;
 }
 
@@ -884,7 +884,7 @@ emupchan_trigger(kobj_t obj, void *data, int go)
 	if (!PCMTRIG_COMMON(go))
 		return 0;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (go == PCMTRIG_START) {
 		emu_vsetup(ch);
 		emu_vwrite(sc, ch->master);
@@ -901,7 +901,7 @@ emupchan_trigger(kobj_t obj, void *data, int go)
 	}
 	ch->run = (go == PCMTRIG_START) ? 1 : 0;
 	emu_vtrigger(sc, ch->master, ch->run);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return 0;
 }
 
@@ -912,9 +912,9 @@ emupchan_getptr(kobj_t obj, void *data)
 	struct sc_info *sc = ch->parent;
 	int r;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	r = emu_vpos(sc, ch->master);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return r;
 }
@@ -984,10 +984,10 @@ emurchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	if (sndbuf_alloc(ch->buffer, sc->parent_dmat, 0, sc->bufsz) != 0)
 		return NULL;
 	else {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		emu_wrptr(sc, 0, ch->basereg, ch->buffer->buf_addr);
 		emu_wrptr(sc, 0, ch->sizereg, 0); /* off */
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return ch;
 	}
 }
@@ -1027,9 +1027,9 @@ emurchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 	struct sc_info *sc = ch->parent;
 
 	ch->blksz = blocksize;
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	emu_settimer(sc);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return blocksize;
 }
 
@@ -1069,7 +1069,7 @@ emurchan_trigger(kobj_t obj, void *data, int go)
 		sz = EMU_RECBS_BUFSIZE_4096;
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch(go) {
 	case PCMTRIG_START:
 		ch->run = 1;
@@ -1111,7 +1111,7 @@ emurchan_trigger(kobj_t obj, void *data, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -1123,9 +1123,9 @@ emurchan_getptr(kobj_t obj, void *data)
 	struct sc_info *sc = ch->parent;
 	int r;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	r = emu_rdptr(sc, 0, ch->idxreg) & 0x0000ffff;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return r;
 }
@@ -1171,9 +1171,9 @@ emu_muninit(struct mpu401 *arg, void *cookie)
 {
 	struct sc_info *sc = cookie;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->mpu_intr = NULL;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -1216,7 +1216,7 @@ emu_intr(void *data)
 	struct sc_info *sc = data;
 	u_int32_t stat, ack, i, x;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	while (1) {
 		stat = emu_rd(sc, EMU_IPR, 4);
 		if (stat == 0)
@@ -1262,7 +1262,7 @@ emu_intr(void *data)
 		emu_wr(sc, EMU_IPR, stat, 4);
 
 		if (ack) {
-			snd_mtxunlock(sc->lock);
+			mtx_unlock(&sc->lock);
 
 			if (ack & EMU_IPR_INTERVALTIMER) {
 				x = 0;
@@ -1289,10 +1289,10 @@ emu_intr(void *data)
 					chn_intr(sc->rch[2].channel);
 			}
 
-			snd_mtxlock(sc->lock);
+			mtx_lock(&sc->lock);
 		}
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 }
 
 /* -------------------------------------------------------------------- */
@@ -2071,7 +2071,8 @@ emu_pci_attach(device_t dev)
 	char status[SND_STATUSLEN];
 
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10k1 softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_emu10k1 softc",
+	    MTX_DEF);
 	sc->dev = dev;
 	sc->type = pci_get_devid(dev);
 	sc->rev = pci_get_revid(dev);
@@ -2147,7 +2148,7 @@ emu_pci_attach(device_t dev)
 	if (sc->ih) bus_teardown_intr(dev, sc->irq, sc->ih);
 	if (sc->irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 	if (sc->parent_dmat) bus_dma_tag_destroy(sc->parent_dmat);
-	if (sc->lock) snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_DEVBUF);
 	return ENXIO;
 }
@@ -2170,7 +2171,7 @@ emu_pci_detach(device_t dev)
 	bus_teardown_intr(dev, sc->irq, sc->ih);
 	bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 	bus_dma_tag_destroy(sc->parent_dmat);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_DEVBUF);
 
 	return 0;

sys/dev/sound/pci/emu10kx-pcm.c

@@ -90,7 +90,7 @@ struct emu_pcm_rchinfo {
 #endif
 
 struct emu_pcm_info {
-	struct mtx		*lock;
+	struct mtx		lock;
 	device_t		dev;		/* device information */
 	struct emu_sc_info 	*card;
 	struct emu_pcm_pchinfo	pch[MAX_CHANNELS];	/* hardware channels */
@@ -771,10 +771,10 @@ emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
 
 	if (blocksize > ch->pcm->bufsz)
 		blocksize = ch->pcm->bufsz;
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ch->blksz = blocksize;
 	emu_timer_set(sc->card, ch->timer, ch->blksz / ch->buffer->align);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return (ch->blksz);
 }
 
@@ -787,7 +787,7 @@ emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 	if (!PCMTRIG_COMMON(go))
 		return (0);
 
-	snd_mtxlock(sc->lock); /* XXX can we trigger on parallel threads ? */
+	mtx_lock(&sc->lock); /* XXX can we trigger on parallel threads ? */
 	if (go == PCMTRIG_START) {
 		emu_vsetup(ch->master, ch->fmt, ch->spd);
 		if (AFMT_CHANNEL(ch->fmt) > 1)
@@ -802,7 +802,7 @@ emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 	/* PCM interrupt handler will handle PCMTRIG_STOP event */
 	ch->run = (go == PCMTRIG_START) ? 1 : 0;
 	emu_vtrigger(sc->card, ch->master, ch->run);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return (0);
 }
 
@@ -970,7 +970,7 @@ emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 		sz = EMU_RECBS_BUFSIZE_4096;
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch (go) {
 	case PCMTRIG_START:
 		ch->run = 1;
@@ -999,7 +999,7 @@ emurchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -1130,7 +1130,7 @@ emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 		sz = EMU_RECBS_BUFSIZE_4096;
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch (go) {
 	case PCMTRIG_START:
 		ch->run = 1;
@@ -1169,7 +1169,7 @@ emufxrchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -1234,24 +1234,24 @@ emu_pcm_intr(void *pcm, uint32_t stat)
 
 	ack = 0;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	if (stat & EMU_IPR_INTERVALTIMER) {
 		ack |= EMU_IPR_INTERVALTIMER;
 		for (i = 0; i < MAX_CHANNELS; i++)
 			if (sc->pch[i].channel) {
 				if (sc->pch[i].run == 1) {
-					snd_mtxunlock(sc->lock);
+					mtx_unlock(&sc->lock);
 					chn_intr(sc->pch[i].channel);
-					snd_mtxlock(sc->lock);
+					mtx_lock(&sc->lock);
 				} else
 					emu_timer_enable(sc->card, sc->pch[i].timer, 0);
 			}
 		/* ADC may install timer to get low-latency interrupts */
 		if ((sc->rch_adc.channel) && (sc->rch_adc.run)) {
-			snd_mtxunlock(sc->lock);
+			mtx_unlock(&sc->lock);
 			chn_intr(sc->rch_adc.channel);
-			snd_mtxlock(sc->lock);
+			mtx_lock(&sc->lock);
 		}
 		/*
 		 * EFX does not use timer, because it will fill
@@ -1262,21 +1262,21 @@ emu_pcm_intr(void *pcm, uint32_t stat)
 	if (stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL)) {
 		ack |= stat & (EMU_IPR_ADCBUFFULL | EMU_IPR_ADCBUFHALFFULL);
 		if (sc->rch_adc.channel) {
-			snd_mtxunlock(sc->lock);
+			mtx_unlock(&sc->lock);
 			chn_intr(sc->rch_adc.channel);
-			snd_mtxlock(sc->lock);
+			mtx_lock(&sc->lock);
 		}
 	}
 
 	if (stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL)) {
 		ack |= stat & (EMU_IPR_EFXBUFFULL | EMU_IPR_EFXBUFHALFFULL);
 		if (sc->rch_efx.channel) {
-			snd_mtxunlock(sc->lock);
+			mtx_unlock(&sc->lock);
 			chn_intr(sc->rch_efx.channel);
-			snd_mtxlock(sc->lock);
+			mtx_lock(&sc->lock);
 		}
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (ack);
 }
@@ -1349,7 +1349,8 @@ emu_pcm_attach(device_t dev)
 		return (ENXIO);
 	}
 
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_emu10kx pcm softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_emu10kx pcm softc",
+	    MTX_DEF);
 	sc->dev = dev;
 
 	BUS_READ_IVAR(device_get_parent(dev), dev, EMU_VAR_ISEMU10K1, &ivar);
@@ -1483,8 +1484,7 @@ emu_pcm_attach(device_t dev)
 bad:
 	if (sc->codec)
 		ac97_destroy(sc->codec);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 	free(sc, M_DEVBUF);
 	return (ENXIO);
 }
@@ -1503,8 +1503,7 @@ emu_pcm_detach(device_t dev)
 
 	emu_pcm_uninit(sc);
 
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 	free(sc, M_DEVBUF);
 
 	return (0);

sys/dev/sound/pci/envy24.c

@@ -116,7 +116,7 @@ struct cfg_info {
 /* device private data */
 struct sc_info {
 	device_t	dev;
-	struct mtx	*lock;
+	struct mtx	lock;
 
 	/* Control/Status registor */
 	struct resource *cs;
@@ -1567,10 +1567,10 @@ envy24chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channe
 #if(0)
 	device_printf(sc->dev, "envy24chan_init(obj, devinfo, b, c, %d)\n", dir);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if ((sc->chnum > ENVY24_CHAN_PLAY_SPDIF && dir != PCMDIR_REC) ||
 	    (sc->chnum < ENVY24_CHAN_REC_ADC1 && dir != PCMDIR_PLAY)) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return NULL;
 	}
 	num = sc->chnum;
@@ -1589,14 +1589,14 @@ envy24chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channe
 		ch->dir = dir;
 		/* set channel map */
 		ch->num = envy24_chanmap[num];
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		sndbuf_setup(ch->buffer, ch->data, ch->size);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		/* these 2 values are dummy */
 		ch->unit = 4;
 		ch->blk = 10240;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return ch;
 }
@@ -1610,12 +1610,12 @@ envy24chan_free(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24chan_free()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->data != NULL) {
 		free(ch->data, M_ENVY24);
 		ch->data = NULL;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -1632,21 +1632,21 @@ envy24chan_setformat(kobj_t obj, void *data, u_int32_t format)
 #if(0)
 	device_printf(sc->dev, "envy24chan_setformat(obj, data, 0x%08x)\n", format);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	/* check and get format related information */
 	if (ch->dir == PCMDIR_PLAY)
 		emltab = envy24_pemltab;
 	else
 		emltab = envy24_remltab;
 	if (emltab == NULL) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return -1;
 	}
 	for (i = 0; emltab[i].format != 0; i++)
 		if (emltab[i].format == format)
 			break;
 	if (emltab[i].format == 0) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return -1;
 	}
 
@@ -1670,7 +1670,7 @@ envy24chan_setformat(kobj_t obj, void *data, u_int32_t format)
 	bcnt = ch->size / bsize;
 	sndbuf_resize(ch->buffer, bcnt, bsize);
 #endif
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if(0)
 	device_printf(sc->dev, "envy24chan_setformat(): return 0x%08x\n", 0);
@@ -1723,7 +1723,7 @@ envy24chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 	device_printf(sc->dev, "envy24chan_setblocksize(obj, data, %d)\n", blocksize);
 #endif
 	prev = 0x7fffffff;
-	/* snd_mtxlock(sc->lock); */
+	/* mtx_lock(&sc->lock); */
 	for (size = ch->size / 2; size > 0; size /= 2) {
 		if (abs(size - blocksize) < abs(prev - blocksize))
 			prev = size;
@@ -1745,7 +1745,7 @@ envy24chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
         bsize *= ch->unit;
         bcnt = ch->size / bsize;
         sndbuf_resize(ch->buffer, bcnt, bsize);
-	/* snd_mtxunlock(sc->lock); */
+	/* mtx_unlock(&sc->lock); */
 
 #if(0)
 	device_printf(sc->dev, "envy24chan_setblocksize(): return %d\n", prev);
@@ -1767,7 +1767,7 @@ envy24chan_trigger(kobj_t obj, void *data, int go)
 
 	device_printf(sc->dev, "envy24chan_trigger(obj, data, %d)\n", go);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY)
 		slot = 0;
 	else
@@ -1862,7 +1862,7 @@ envy24chan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 fail:
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return (error);
 }
 
@@ -1876,10 +1876,10 @@ envy24chan_getptr(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24chan_getptr()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ptr = envy24_gethwptr(sc, ch->dir);
 	rtn = ptr * ch->unit;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if(0)
 	device_printf(sc->dev, "envy24chan_getptr(): return %d\n",
@@ -1898,7 +1898,7 @@ envy24chan_getcaps(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24chan_getcaps()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		if (sc->run[0] == 0)
 			rtn = &envy24_playcaps;
@@ -1911,7 +1911,7 @@ envy24chan_getcaps(kobj_t obj, void *data)
 		else
 			rtn = &sc->caps[1];
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return rtn;
 }
@@ -1945,12 +1945,12 @@ envy24mixer_init(struct snd_mixer *m)
 		return -1;
 
 	/* set volume control rate */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	envy24_wrmt(sc, ENVY24_MT_VOLRATE, 0x30, 1); /* 0x30 is default value */
 
 	mix_setdevs(m, ENVY24_MIX_MASK);
 	mix_setrecdevs(m, ENVY24_MIX_REC_MASK);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -2003,7 +2003,7 @@ envy24mixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right
 	    dev, left, right);
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (dev == 0) {
 		for (i = 0; i < sc->dacn; i++) {
 			sc->cfg->codec->setvolume(sc->dac[i], PCMDIR_PLAY, left, right);
@@ -2020,7 +2020,7 @@ envy24mixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right
 		if (hwch > ENVY24_CHAN_PLAY_SPDIF || sc->chan[ch].run)
 			envy24_setvolume(sc, hwch);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return right << 8 | left;
 }
@@ -2063,7 +2063,7 @@ envy24_intr(void *p)
 #if(0)
 	device_printf(sc->dev, "envy24_intr()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (envy24_checkintr(sc, PCMDIR_PLAY)) {
 #if(0)
 		device_printf(sc->dev, "envy24_intr(): play\n");
@@ -2085,9 +2085,9 @@ envy24_intr(void *p)
 				device_printf(sc->dev, "envy24_intr(): chan[%d].blk = %d\n", i, ch->blk);
 #endif
 			if (ch->run && ch->blk <= feed) {
-				snd_mtxunlock(sc->lock);
+				mtx_unlock(&sc->lock);
 				chn_intr(ch->channel);
-				snd_mtxlock(sc->lock);
+				mtx_lock(&sc->lock);
 			}
 		}
 		sc->intr[0] = ptr;
@@ -2104,15 +2104,15 @@ envy24_intr(void *p)
 		for (i = ENVY24_CHAN_REC_ADC1; i <= ENVY24_CHAN_REC_SPDIF; i++) {
 			ch = &sc->chan[i];
 			if (ch->run && ch->blk <= feed) {
-				snd_mtxunlock(sc->lock);
+				mtx_unlock(&sc->lock);
 				chn_intr(ch->channel);
-				snd_mtxlock(sc->lock);
+				mtx_lock(&sc->lock);
 			}
 		}
 		sc->intr[1] = ptr;
 		envy24_updintr(sc, PCMDIR_REC);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return;
 }
@@ -2551,7 +2551,8 @@ envy24_pci_attach(device_t dev)
 	}
 
 	bzero(sc, sizeof(*sc));
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_envy24 softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_envy24 softc",
+	    MTX_DEF);
 	sc->dev = dev;
 
 	/* initialize PCI interface */
@@ -2627,8 +2628,7 @@ envy24_pci_attach(device_t dev)
 		bus_release_resource(dev, SYS_RES_IOPORT, sc->dsid, sc->ds);
 	if (sc->mt)
 		bus_release_resource(dev, SYS_RES_IOPORT, sc->mtid, sc->mt);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 	free(sc, M_ENVY24);
 	return err;
 }
@@ -2665,7 +2665,7 @@ envy24_pci_detach(device_t dev)
 	bus_release_resource(dev, SYS_RES_IOPORT, sc->ddmaid, sc->ddma);
 	bus_release_resource(dev, SYS_RES_IOPORT, sc->dsid, sc->ds);
 	bus_release_resource(dev, SYS_RES_IOPORT, sc->mtid, sc->mt);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_ENVY24);
 	return 0;
 }

sys/dev/sound/pci/envy24ht.c

@@ -125,7 +125,7 @@ struct cfg_info {
 /* device private data */
 struct sc_info {
 	device_t	dev;
-	struct mtx	*lock;
+	struct mtx	lock;
 
 	/* Control/Status registor */
 	struct resource *cs;
@@ -1476,11 +1476,11 @@ envy24htchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_chan
 #if(0)
 	device_printf(sc->dev, "envy24htchan_init(obj, devinfo, b, c, %d)\n", dir);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 #if 0
 	if ((sc->chnum > ENVY24HT_CHAN_PLAY_SPDIF && dir != PCMDIR_REC) ||
 	    (sc->chnum < ENVY24HT_CHAN_REC_ADC1 && dir != PCMDIR_PLAY)) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return NULL;
 	}
 #endif
@@ -1500,14 +1500,14 @@ envy24htchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_chan
 		ch->dir = dir;
 		/* set channel map */
 		ch->num = envy24ht_chanmap[num];
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		sndbuf_setup(ch->buffer, ch->data, ch->size);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		/* these 2 values are dummy */
 		ch->unit = 4;
 		ch->blk = 10240;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return ch;
 }
@@ -1521,12 +1521,12 @@ envy24htchan_free(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24htchan_free()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->data != NULL) {
 		free(ch->data, M_ENVY24HT);
 		ch->data = NULL;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -1543,21 +1543,21 @@ envy24htchan_setformat(kobj_t obj, void *data, u_int32_t format)
 #if(0)
 	device_printf(sc->dev, "envy24htchan_setformat(obj, data, 0x%08x)\n", format);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	/* check and get format related information */
 	if (ch->dir == PCMDIR_PLAY)
 		emltab = envy24ht_pemltab;
 	else
 		emltab = envy24ht_remltab;
 	if (emltab == NULL) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return -1;
 	}
 	for (i = 0; emltab[i].format != 0; i++)
 		if (emltab[i].format == format)
 			break;
 	if (emltab[i].format == 0) {
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		return -1;
 	}
 
@@ -1581,7 +1581,7 @@ envy24htchan_setformat(kobj_t obj, void *data, u_int32_t format)
 	bcnt = ch->size / bsize;
 	sndbuf_resize(ch->buffer, bcnt, bsize);
 #endif
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if(0)
 	device_printf(sc->dev, "envy24htchan_setformat(): return 0x%08x\n", 0);
@@ -1634,7 +1634,7 @@ envy24htchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 	device_printf(sc->dev, "envy24htchan_setblocksize(obj, data, %d)\n", blocksize);
 #endif
 	prev = 0x7fffffff;
-	/* snd_mtxlock(sc->lock); */
+	/* mtx_lock(&sc->lock); */
 	for (size = ch->size / 2; size > 0; size /= 2) {
 		if (abs(size - blocksize) < abs(prev - blocksize))
 			prev = size;
@@ -1656,7 +1656,7 @@ envy24htchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
         bsize *= ch->unit;
         bcnt = ch->size / bsize;
         sndbuf_resize(ch->buffer, bcnt, bsize);
-	/* snd_mtxunlock(sc->lock); */
+	/* mtx_unlock(&sc->lock); */
 
 #if(0)
 	device_printf(sc->dev, "envy24htchan_setblocksize(): return %d\n", prev);
@@ -1678,7 +1678,7 @@ envy24htchan_trigger(kobj_t obj, void *data, int go)
 
 	device_printf(sc->dev, "envy24htchan_trigger(obj, data, %d)\n", go);
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY)
 		slot = 0;
 	else
@@ -1771,7 +1771,7 @@ envy24htchan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 fail:
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 	return (error);
 }
 
@@ -1785,10 +1785,10 @@ envy24htchan_getptr(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24htchan_getptr()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ptr = envy24ht_gethwptr(sc, ch->dir);
 	rtn = ptr * ch->unit;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if(0)
 	device_printf(sc->dev, "envy24htchan_getptr(): return %d\n",
@@ -1807,7 +1807,7 @@ envy24htchan_getcaps(kobj_t obj, void *data)
 #if(0)
 	device_printf(sc->dev, "envy24htchan_getcaps()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->dir == PCMDIR_PLAY) {
 		if (sc->run[0] == 0)
 			rtn = &envy24ht_playcaps;
@@ -1820,7 +1820,7 @@ envy24htchan_getcaps(kobj_t obj, void *data)
 		else
 			rtn = &sc->caps[1];
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return rtn;
 }
@@ -1854,7 +1854,7 @@ envy24htmixer_init(struct snd_mixer *m)
 		return -1;
 
 	/* set volume control rate */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 #if 0
 	envy24ht_wrmt(sc, ENVY24HT_MT_VOLRATE, 0x30, 1); /* 0x30 is default value */
 #endif
@@ -1864,7 +1864,7 @@ envy24htmixer_init(struct snd_mixer *m)
 	mix_setdevs(m, ENVY24HT_MIX_MASK);
 	mix_setrecdevs(m, ENVY24HT_MIX_REC_MASK);
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return 0;
 }
@@ -1917,7 +1917,7 @@ envy24htmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned rig
 	    dev, left, right);
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (dev == 0) {
 		for (i = 0; i < sc->dacn; i++) {
 			sc->cfg->codec->setvolume(sc->dac[i], PCMDIR_PLAY, left, right);
@@ -1934,7 +1934,7 @@ envy24htmixer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned rig
 		if (hwch > ENVY24HT_CHAN_PLAY_SPDIF || sc->chan[ch].run)
 			envy24ht_setvolume(sc, hwch);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return right << 8 | left;
 }
@@ -1977,7 +1977,7 @@ envy24ht_intr(void *p)
 #if(0)
 	device_printf(sc->dev, "envy24ht_intr()\n");
 #endif
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (envy24ht_checkintr(sc, PCMDIR_PLAY)) {
 #if(0)
 		device_printf(sc->dev, "envy24ht_intr(): play\n");
@@ -1999,9 +1999,9 @@ envy24ht_intr(void *p)
 				device_printf(sc->dev, "envy24ht_intr(): chan[%d].blk = %d\n", i, ch->blk);
 #endif
 			if (ch->run && ch->blk <= feed) {
-				snd_mtxunlock(sc->lock);
+				mtx_unlock(&sc->lock);
 				chn_intr(ch->channel);
-				snd_mtxlock(sc->lock);
+				mtx_lock(&sc->lock);
 			}
 		}
 		sc->intr[0] = ptr;
@@ -2018,15 +2018,15 @@ envy24ht_intr(void *p)
 		for (i = ENVY24HT_CHAN_REC_ADC1; i <= ENVY24HT_CHAN_REC_SPDIF; i++) {
 			ch = &sc->chan[i];
 			if (ch->run && ch->blk <= feed) {
-				snd_mtxunlock(sc->lock);
+				mtx_unlock(&sc->lock);
 				chn_intr(ch->channel);
-				snd_mtxlock(sc->lock);
+				mtx_lock(&sc->lock);
 			}
 		}
 		sc->intr[1] = ptr;
 		envy24ht_updintr(sc, PCMDIR_REC);
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return;
 }
@@ -2455,8 +2455,8 @@ envy24ht_pci_attach(device_t dev)
 	}
 
 	bzero(sc, sizeof(*sc));
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_eny24ht softc",
-	    "snd_envy24ht softc");
+	    MTX_DEF);
 	sc->dev = dev;
 
 	/* initialize PCI interface */
@@ -2524,8 +2524,7 @@ envy24ht_pci_attach(device_t dev)
 		bus_release_resource(dev, SYS_RES_IOPORT, sc->csid, sc->cs);
 	if (sc->mt)
 		bus_release_resource(dev, SYS_RES_IOPORT, sc->mtid, sc->mt);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 	free(sc, M_ENVY24HT);
 	return err;
 }
@@ -2560,7 +2559,7 @@ envy24ht_pci_detach(device_t dev)
 	bus_release_resource(dev, SYS_RES_IRQ, sc->irqid, sc->irq);
 	bus_release_resource(dev, SYS_RES_IOPORT, sc->csid, sc->cs);
 	bus_release_resource(dev, SYS_RES_IOPORT, sc->mtid, sc->mt);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	free(sc, M_ENVY24HT);
 	return 0;
 }

sys/dev/sound/pci/es137x.c

@@ -224,14 +224,14 @@ struct es_info {
 	uint32_t	sctrl;
 	uint32_t	escfg;
 	struct es_chinfo ch[ES_NCHANS];
-	struct mtx	*lock;
+	struct mtx	lock;
 	struct callout	poll_timer;
 	int poll_ticks, polling;
 };
 
-#define ES_LOCK(sc)		snd_mtxlock((sc)->lock)
+#define ES_LOCK(sc)		mtx_lock(&(sc)->lock)
-#define ES_UNLOCK(sc)		snd_mtxunlock((sc)->lock)
+#define ES_UNLOCK(sc)		mtx_unlock(&(sc)->lock)
-#define ES_LOCK_ASSERT(sc)	snd_mtxassert((sc)->lock)
+#define ES_LOCK_ASSERT(sc)	mtx_assert(&(sc)->lock, MA_OWNED)
 
 /* prototypes */
 static void     es_intr(void *);
@@ -1712,7 +1712,8 @@ es_pci_attach(device_t dev)
 	uint32_t devid;
 
 	es = malloc(sizeof *es, M_DEVBUF, M_WAITOK | M_ZERO);
-	es->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_es137x softc");
+	mtx_init(&es->lock, device_get_nameunit(dev), "snd_es137x softc",
+	    MTX_DEF);
 	es->dev = dev;
 	es->escfg = 0;
 	mapped = 0;
@@ -1888,8 +1889,7 @@ es_pci_attach(device_t dev)
 		ac97_destroy(codec);
 	if (es->reg)
 		bus_release_resource(dev, es->regtype, es->regid, es->reg);
-	if (es->lock)
+	mtx_destroy(&es->lock);
-		snd_mtxfree(es->lock);
 	if (es)
 		free(es, M_DEVBUF);
 	return (ENXIO);
@@ -1919,7 +1919,7 @@ es_pci_detach(device_t dev)
 	bus_release_resource(dev, SYS_RES_IRQ, es->irqid, es->irq);
 	bus_release_resource(dev, es->regtype, es->regid, es->reg);
 	bus_dma_tag_destroy(es->parent_dmat);
-	snd_mtxfree(es->lock);
+	mtx_destroy(&es->lock);
 	free(es, M_DEVBUF);
 
 	return (0);

sys/dev/sound/pci/hda/hdaa.c

@@ -47,9 +47,9 @@
 
 #include "mixer_if.h"
 
-#define hdaa_lock(devinfo)	snd_mtxlock((devinfo)->lock)
+#define hdaa_lock(devinfo)	mtx_lock((devinfo)->lock)
-#define hdaa_unlock(devinfo)	snd_mtxunlock((devinfo)->lock)
+#define hdaa_unlock(devinfo)	mtx_unlock((devinfo)->lock)
-#define hdaa_lockassert(devinfo) snd_mtxassert((devinfo)->lock)
+#define hdaa_lockassert(devinfo) mtx_assert((devinfo)->lock, MA_OWNED)
 
 static const struct {
 	const char *key;

sys/dev/sound/pci/hda/hdac.c

@@ -51,9 +51,9 @@
 
 #define HDA_DRV_TEST_REV	"20120126_0002"
 
-#define hdac_lock(sc)		snd_mtxlock((sc)->lock)
+#define hdac_lock(sc)		mtx_lock(&(sc)->lock)
-#define hdac_unlock(sc)		snd_mtxunlock((sc)->lock)
+#define hdac_unlock(sc)		mtx_unlock(&(sc)->lock)
-#define hdac_lockassert(sc)	snd_mtxassert((sc)->lock)
+#define hdac_lockassert(sc)	mtx_assert(&(sc)->lock, MA_OWNED)
 
 #define HDAC_QUIRK_64BIT	(1 << 0)
 #define HDAC_QUIRK_DMAPOS	(1 << 1)
@@ -1171,7 +1171,8 @@ hdac_attach(device_t dev)
 		}
 	}
 
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "HDA driver mutex");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "HDA driver mutex",
+	    MTX_DEF);
 	sc->dev = dev;
 	TASK_INIT(&sc->unsolq_task, 0, hdac_unsolq_task, sc);
 	callout_init(&sc->poll_callout, 1);
@@ -1374,7 +1375,7 @@ hdac_attach(device_t dev)
 	hdac_dma_free(sc, &sc->rirb_dma);
 	hdac_dma_free(sc, &sc->corb_dma);
 	hdac_mem_free(sc);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 
 	return (ENXIO);
 }
@@ -1798,7 +1799,7 @@ hdac_detach(device_t dev)
 		sc->chan_dmat = NULL;
 	}
 	hdac_mem_free(sc);
-	snd_mtxfree(sc->lock);
+	mtx_destroy(&sc->lock);
 	return (0);
 }
 
@@ -1888,7 +1889,7 @@ hdac_get_mtx(device_t dev, device_t child)
 {
 	struct hdac_softc *sc = device_get_softc(dev);
 
-	return (sc->lock);
+	return (&sc->lock);
 }
 
 static uint32_t

sys/dev/sound/pci/hda/hdac_private.h

@@ -162,7 +162,7 @@ struct hdac_stream {
 
 struct hdac_softc {
 	device_t	dev;
-	struct mtx	*lock;
+	struct mtx	lock;
 
 	struct intr_config_hook intrhook;
 

sys/dev/sound/pci/hda/hdacc.c

@@ -60,9 +60,9 @@ struct hdacc_softc {
 	struct hdacc_fg	*fgs;
 };
 
-#define hdacc_lock(codec)	snd_mtxlock((codec)->lock)
+#define hdacc_lock(codec)	mtx_lock((codec)->lock)
-#define hdacc_unlock(codec)	snd_mtxunlock((codec)->lock)
+#define hdacc_unlock(codec)	mtx_unlock((codec)->lock)
-#define hdacc_lockassert(codec)	snd_mtxassert((codec)->lock)
+#define hdacc_lockassert(codec)	mtx_assert((codec)->lock, MA_OWNED)
 
 MALLOC_DEFINE(M_HDACC, "hdacc", "HDA CODEC");
 

sys/dev/sound/pci/hdsp-pcm.c

@@ -321,10 +321,10 @@ hdspmixer_init(struct snd_mixer *m)
 	if (hdsp_channel_rec_ports(scp->hc))
 		mask |= SOUND_MASK_RECLEV;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 	mix_setdevs(m, mask);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -676,7 +676,7 @@ hdspchan_free(kobj_t obj, void *data)
 	device_printf(scp->dev, "hdspchan_free()\n");
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->data != NULL) {
 		free(ch->data, M_HDSP);
 		ch->data = NULL;
@@ -685,7 +685,7 @@ hdspchan_free(kobj_t obj, void *data)
 		free(ch->caps, M_HDSP);
 		ch->caps = NULL;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -702,7 +702,7 @@ hdspchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	scp = devinfo;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	num = scp->chnum;
 
 	ch = &scp->chan[num];
@@ -745,7 +745,7 @@ hdspchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 
 	ch->dir = dir;
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
 		device_printf(scp->dev, "Can't setup sndbuf.\n");
@@ -767,7 +767,7 @@ hdspchan_trigger(kobj_t obj, void *data, int go)
 	scp = ch->parent;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch (go) {
 	case PCMTRIG_START:
 #if 0
@@ -795,7 +795,7 @@ hdspchan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -812,9 +812,9 @@ hdspchan_getptr(kobj_t obj, void *data)
 	scp = ch->parent;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ret = hdsp_read_2(sc, HDSP_STATUS_REG);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	pos = ret & HDSP_BUF_POSITION_MASK;
 	pos %= (2 * sc->period * sizeof(uint32_t)); /* Double buffer. */
@@ -951,12 +951,12 @@ hdspchan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
 		}
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->ctrl_register &= ~HDSP_LAT_MASK;
 	sc->ctrl_register |= hdsp_encode_latency(hl->n);
 	hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
 	sc->period = hl->period;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if 0
 	device_printf(scp->dev, "New period=%d\n", sc->period);
@@ -1034,9 +1034,9 @@ hdsp_pcm_intr(struct sc_pcminfo *scp)
 
 	for (i = 0; i < scp->chnum; i++) {
 		ch = &scp->chan[i];
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		chn_intr(ch->channel);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 	}
 
 	return (0);

sys/dev/sound/pci/hdsp.c

@@ -109,7 +109,7 @@ hdsp_intr(void *p)
 
 	sc = (struct sc_info *)p;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	status = hdsp_read_1(sc, HDSP_STATUS_REG);
 	if (status & HDSP_AUDIO_IRQ_PENDING) {
@@ -126,7 +126,7 @@ hdsp_intr(void *p)
 		free(devlist, M_TEMP);
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 }
 
 static void
@@ -286,11 +286,11 @@ hdsp_sysctl_input_level(SYSCTL_HANDLER_ARGS)
 	/* Set input level in control register. */
 	control &= HDSP_INPUT_LEVEL_MASK;
 	if (control != (sc->ctrl_register & HDSP_INPUT_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->ctrl_register &= ~HDSP_INPUT_LEVEL_MASK;
 		sc->ctrl_register |= control;
 		hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -350,11 +350,11 @@ hdsp_sysctl_output_level(SYSCTL_HANDLER_ARGS)
 	/* Set output level in control register. */
 	control &= HDSP_OUTPUT_LEVEL_MASK;
 	if (control != (sc->ctrl_register & HDSP_OUTPUT_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->ctrl_register &= ~HDSP_OUTPUT_LEVEL_MASK;
 		sc->ctrl_register |= control;
 		hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -414,11 +414,11 @@ hdsp_sysctl_phones_level(SYSCTL_HANDLER_ARGS)
 	/* Set phones level in control register. */
 	control &= HDSP_PHONES_LEVEL_MASK;
 	if (control != (sc->ctrl_register & HDSP_PHONES_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->ctrl_register &= ~HDSP_PHONES_LEVEL_MASK;
 		sc->ctrl_register |= control;
 		hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -549,11 +549,11 @@ hdsp_sysctl_clock_preference(SYSCTL_HANDLER_ARGS)
 	if (clock->name != NULL) {
 		control = hdsp_control_clock_preference(clock->type);
 		control &= HDSP_CONTROL_CLOCK_MASK;
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->ctrl_register &= ~HDSP_CONTROL_CLOCK_MASK;
 		sc->ctrl_register |= control;
 		hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -600,10 +600,10 @@ hdsp_sysctl_clock_source(SYSCTL_HANDLER_ARGS)
 		return (ENXIO);
 
 	/* Read current (autosync) clock source from status2 register. */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	status2 = hdsp_read_4(sc, HDSP_STATUS2_REG);
 	status2 &= HDSP_STATUS2_CLOCK_MASK;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	/* Translate status2 register value to clock source. */
 	for (clock = clock_table; clock->name != NULL; ++clock) {
@@ -720,10 +720,10 @@ hdsp_sysctl_sync_status(SYSCTL_HANDLER_ARGS)
 		return (ENXIO);
 
 	/* Read current lock and sync bits from status registers. */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	status = hdsp_read_4(sc, HDSP_STATUS_REG);
 	status2 = hdsp_read_4(sc, HDSP_STATUS2_REG);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	/* List clock sources with lock and sync state. */
 	for (clock = clock_table; clock->name != NULL; ++clock) {
@@ -857,8 +857,8 @@ hdsp_attach(device_t dev)
 #endif
 
 	sc = device_get_softc(dev);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_hdsp softc",
-	    "snd_hdsp softc");
+	    MTX_DEF);
 	sc->dev = dev;
 
 	pci_enable_busmaster(dev);
@@ -999,8 +999,7 @@ hdsp_detach(device_t dev)
 		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 	if (sc->cs)
 		bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), sc->cs);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 
 	return (0);
 }

sys/dev/sound/pci/hdsp.h

@@ -223,7 +223,7 @@ struct sc_pcminfo {
 /* HDSP device private data */
 struct sc_info {
 	device_t		dev;
-	struct mtx		*lock;
+	struct mtx		lock;
 
 	uint32_t		ctrl_register;
 	uint32_t		type;

sys/dev/sound/pci/hdspe-pcm.c

@@ -305,10 +305,10 @@ hdspemixer_init(struct snd_mixer *m)
 	if (hdspe_channel_rec_ports(scp->hc))
 		mask |= SOUND_MASK_RECLEV;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
 	mix_setdevs(m, mask);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -667,7 +667,7 @@ hdspechan_free(kobj_t obj, void *data)
 	device_printf(scp->dev, "hdspechan_free()\n");
 #endif
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	if (ch->data != NULL) {
 		free(ch->data, M_HDSPE);
 		ch->data = NULL;
@@ -676,7 +676,7 @@ hdspechan_free(kobj_t obj, void *data)
 		free(ch->caps, M_HDSPE);
 		ch->caps = NULL;
 	}
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -693,7 +693,7 @@ hdspechan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	scp = devinfo;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	num = scp->chnum;
 
 	ch = &scp->chan[num];
@@ -729,7 +729,7 @@ hdspechan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 
 	ch->dir = dir;
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
 		device_printf(scp->dev, "Can't setup sndbuf.\n");
@@ -751,7 +751,7 @@ hdspechan_trigger(kobj_t obj, void *data, int go)
 	scp = ch->parent;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	switch (go) {
 	case PCMTRIG_START:
 #if 0
@@ -779,7 +779,7 @@ hdspechan_trigger(kobj_t obj, void *data, int go)
 		break;
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	return (0);
 }
@@ -796,9 +796,9 @@ hdspechan_getptr(kobj_t obj, void *data)
 	scp = ch->parent;
 	sc = scp->sc;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	ret = hdspe_read_2(sc, HDSPE_STATUS_REG);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	pos = ret & HDSPE_BUF_POSITION_MASK;
 	pos *= AFMT_CHANNEL(ch->format); /* Hardbuf with multiple channels. */
@@ -946,12 +946,12 @@ hdspechan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
 		}
 	}
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	sc->ctrl_register &= ~HDSPE_LAT_MASK;
 	sc->ctrl_register |= hdspe_encode_latency(hl->n);
 	hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
 	sc->period = hl->period;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 #if 0
 	device_printf(scp->dev, "New period=%d\n", sc->period);
@@ -1025,9 +1025,9 @@ hdspe_pcm_intr(struct sc_pcminfo *scp)
 
 	for (i = 0; i < scp->chnum; i++) {
 		ch = &scp->chan[i];
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 		chn_intr(ch->channel);
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 	}
 
 	return (0);

sys/dev/sound/pci/hdspe.c

@@ -119,7 +119,7 @@ hdspe_intr(void *p)
 
 	sc = (struct sc_info *)p;
 
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 
 	status = hdspe_read_1(sc, HDSPE_STATUS_REG);
 	if (status & HDSPE_AUDIO_IRQ_PENDING) {
@@ -136,7 +136,7 @@ hdspe_intr(void *p)
 		free(devlist, M_TEMP);
 	}
 
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 }
 
 static void
@@ -301,11 +301,11 @@ hdspe_sysctl_input_level(SYSCTL_HANDLER_ARGS)
 	/* Set input level in settings register. */
 	settings &= HDSPE_INPUT_LEVEL_MASK;
 	if (settings != (sc->settings_register & HDSPE_INPUT_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->settings_register &= ~HDSPE_INPUT_LEVEL_MASK;
 		sc->settings_register |= settings;
 		hdspe_write_4(sc, HDSPE_SETTINGS_REG, sc->settings_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -365,11 +365,11 @@ hdspe_sysctl_output_level(SYSCTL_HANDLER_ARGS)
 	/* Set output level in settings register. */
 	settings &= HDSPE_OUTPUT_LEVEL_MASK;
 	if (settings != (sc->settings_register & HDSPE_OUTPUT_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->settings_register &= ~HDSPE_OUTPUT_LEVEL_MASK;
 		sc->settings_register |= settings;
 		hdspe_write_4(sc, HDSPE_SETTINGS_REG, sc->settings_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -429,11 +429,11 @@ hdspe_sysctl_phones_level(SYSCTL_HANDLER_ARGS)
 	/* Set phones level in settings register. */
 	settings &= HDSPE_PHONES_LEVEL_MASK;
 	if (settings != (sc->settings_register & HDSPE_PHONES_LEVEL_MASK)) {
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->settings_register &= ~HDSPE_PHONES_LEVEL_MASK;
 		sc->settings_register |= settings;
 		hdspe_write_4(sc, HDSPE_SETTINGS_REG, sc->settings_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -540,11 +540,11 @@ hdspe_sysctl_clock_preference(SYSCTL_HANDLER_ARGS)
 	/* Set preferred clock source in settings register. */
 	if (clock->name != NULL) {
 		setting = clock->setting & HDSPE_SETTING_CLOCK_MASK;
-		snd_mtxlock(sc->lock);
+		mtx_lock(&sc->lock);
 		sc->settings_register &= ~HDSPE_SETTING_CLOCK_MASK;
 		sc->settings_register |= setting;
 		hdspe_write_4(sc, HDSPE_SETTINGS_REG, sc->settings_register);
-		snd_mtxunlock(sc->lock);
+		mtx_unlock(&sc->lock);
 	}
 	return (0);
 }
@@ -568,10 +568,10 @@ hdspe_sysctl_clock_source(SYSCTL_HANDLER_ARGS)
 		return (ENXIO);
 
 	/* Read current (autosync) clock source from status register. */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	status = hdspe_read_4(sc, HDSPE_STATUS1_REG);
 	status &= HDSPE_STATUS1_CLOCK_MASK;
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	/* Translate status register value to clock source. */
 	for (clock = clock_table; clock->name != NULL; ++clock) {
@@ -640,9 +640,9 @@ hdspe_sysctl_sync_status(SYSCTL_HANDLER_ARGS)
 		return (ENXIO);
 
 	/* Read current lock and sync bits from status register. */
-	snd_mtxlock(sc->lock);
+	mtx_lock(&sc->lock);
 	status = hdspe_read_4(sc, HDSPE_STATUS1_REG);
-	snd_mtxunlock(sc->lock);
+	mtx_unlock(&sc->lock);
 
 	/* List clock sources with lock and sync state. */
 	for (clock = clock_table; clock->name != NULL; ++clock) {
@@ -749,8 +749,8 @@ hdspe_attach(device_t dev)
 #endif
 
 	sc = device_get_softc(dev);
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_hdspe softc",
-	    "snd_hdspe softc");
+	    MTX_DEF);
 	sc->dev = dev;
 
 	pci_enable_busmaster(dev);
@@ -891,8 +891,7 @@ hdspe_detach(device_t dev)
 		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq);
 	if (sc->cs)
 		bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), sc->cs);
-	if (sc->lock)
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
 
 	return (0);
 }

sys/dev/sound/pci/hdspe.h

@@ -214,7 +214,7 @@ struct sc_pcminfo {
 /* HDSPe device private data */
 struct sc_info {
 	device_t		dev;
-	struct mtx		*lock;
+	struct mtx		lock;
 
 	uint32_t		ctrl_register;
 	uint32_t		settings_register;

sys/dev/sound/pci/ich.c

@@ -77,9 +77,9 @@
 #define AMD_768		0x7445
 #define AMD_8111	0x746d
 
-#define ICH_LOCK(sc)		snd_mtxlock((sc)->ich_lock)
+#define ICH_LOCK(sc)		mtx_lock(&(sc)->ich_lock)
-#define ICH_UNLOCK(sc)		snd_mtxunlock((sc)->ich_lock)
+#define ICH_UNLOCK(sc)		mtx_unlock(&(sc)->ich_lock)
-#define ICH_LOCK_ASSERT(sc)	snd_mtxassert((sc)->ich_lock)
+#define ICH_LOCK_ASSERT(sc)	mtx_assert(&(sc)->ich_lock, MA_OWNED)
 
 #if 0
 #define ICH_DEBUG(stmt)		do {	\
@@ -196,7 +196,7 @@ struct sc_info {
 	uint16_t vendor;
 	uint16_t devid;
 	uint32_t flags;
-	struct mtx *ich_lock;
+	struct mtx ich_lock;
 };
 
 /* -------------------------------------------------------------------- */
@@ -888,7 +888,8 @@ ich_pci_attach(device_t dev)
 	int			i;
 
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
-	sc->ich_lock = snd_mtxcreate(device_get_nameunit(dev), "snd_ich softc");
+	mtx_init(&sc->ich_lock, device_get_nameunit(dev), "snd_ich softc",
+	    MTX_DEF);
 	sc->dev = dev;
 
 	vendor = sc->vendor = pci_get_vendor(dev);
@@ -1111,8 +1112,7 @@ ich_pci_attach(device_t dev)
 		bus_dma_tag_destroy(sc->chan_dmat);
 	if (sc->dmat)
 		bus_dma_tag_destroy(sc->dmat);
-	if (sc->ich_lock)
+	mtx_destroy(&sc->ich_lock);
-		snd_mtxfree(sc->ich_lock);
 	free(sc, M_DEVBUF);
 	return (ENXIO);
 }
@@ -1136,7 +1136,7 @@ ich_pci_detach(device_t dev)
 	bus_dmamem_free(sc->dmat, sc->dtbl, sc->dtmap);
 	bus_dma_tag_destroy(sc->chan_dmat);
 	bus_dma_tag_destroy(sc->dmat);
-	snd_mtxfree(sc->ich_lock);
+	mtx_destroy(&sc->ich_lock);
 	free(sc, M_DEVBUF);
 	return (0);
 }

sys/dev/sound/pci/maestro3.c

@@ -156,12 +156,12 @@ struct sc_info {
 	unsigned int		bufsz;
 	u_int16_t		*savemem;
 
-	struct mtx		*sc_lock;
+	struct mtx		sc_lock;
 };
 
-#define M3_LOCK(_sc)		snd_mtxlock((_sc)->sc_lock)
+#define M3_LOCK(_sc)		mtx_lock(&(_sc)->sc_lock)
-#define M3_UNLOCK(_sc)		snd_mtxunlock((_sc)->sc_lock)
+#define M3_UNLOCK(_sc)		mtx_unlock(&(_sc)->sc_lock)
-#define M3_LOCK_ASSERT(_sc)	snd_mtxassert((_sc)->sc_lock)
+#define M3_LOCK_ASSERT(_sc)	mtx_assert(&(_sc)->sc_lock, MA_OWNED)
 
 /* -------------------------------------------------------------------- */
 
@@ -1325,8 +1325,8 @@ m3_pci_attach(device_t dev)
 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 	sc->dev = dev;
 	sc->type = pci_get_devid(dev);
-	sc->sc_lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&sc->sc_lock, device_get_nameunit(dev), "snd_maestro3 softc",
-	    "snd_maestro3 softc");
+	    MTX_DEF);
 	for (card = m3_card_types ; card->pci_id ; card++) {
 		if (sc->type == card->pci_id) {
 			sc->which = card->which;
@@ -1465,8 +1465,7 @@ m3_pci_attach(device_t dev)
 		bus_release_resource(dev, sc->regtype, sc->regid, sc->reg);
 	if (sc->parent_dmat)
 		bus_dma_tag_destroy(sc->parent_dmat);
-	if (sc->sc_lock)
+	mtx_destroy(&sc->sc_lock);
-		snd_mtxfree(sc->sc_lock);
 	free(sc, M_DEVBUF);
 	return ENXIO;
 }
@@ -1494,7 +1493,7 @@ m3_pci_detach(device_t dev)
 	bus_dma_tag_destroy(sc->parent_dmat);
 
 	free(sc->savemem, M_DEVBUF);
-	snd_mtxfree(sc->sc_lock);
+	mtx_destroy(&sc->sc_lock);
 	free(sc, M_DEVBUF);
 	return 0;
 }

sys/dev/sound/pci/solo.c

@@ -97,12 +97,12 @@ struct ess_info {
 	unsigned int bufsz;
 
     	struct ess_chinfo pch, rch;
-	struct mtx *lock;
+	struct mtx lock;
 };
 
-#define ess_lock(_ess) snd_mtxlock((_ess)->lock)
+#define ess_lock(_ess) mtx_lock(&(_ess)->lock)
-#define ess_unlock(_ess) snd_mtxunlock((_ess)->lock)
+#define ess_unlock(_ess) mtx_unlock(&(_ess)->lock)
-#define ess_lock_assert(_ess) snd_mtxassert((_ess)->lock)
+#define ess_lock_assert(_ess) mtx_assert(&(_ess)->lock, MA_OWNED)
 
 static int ess_rd(struct ess_info *sc, int reg);
 static void ess_wr(struct ess_info *sc, int reg, u_int8_t val);
@@ -855,10 +855,7 @@ ess_release_resources(struct ess_info *sc, device_t dev)
 		sc->parent_dmat = 0;
     	}
 
-	if (sc->lock) {
+	mtx_destroy(&sc->lock);
-		snd_mtxfree(sc->lock);
-		sc->lock = NULL;
-	}
 
     	free(sc, M_DEVBUF);
 }
@@ -887,10 +884,11 @@ ess_alloc_resources(struct ess_info *sc, device_t dev)
 	sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 		RF_ACTIVE | RF_SHAREABLE);
 
-	sc->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_solo softc");
+	mtx_init(&sc->lock, device_get_nameunit(dev), "snd_solo softc",
+	    MTX_DEF);
 
 	return (sc->irq && sc->io && sc->sb && sc->vc &&
-				sc->mpu && sc->gp && sc->lock)? 0 : ENXIO;
+				sc->mpu && sc->gp)? 0 : ENXIO;
 }
 
 static int

sys/dev/sound/pci/spicds.c

@@ -49,7 +49,7 @@ struct spicds_info {
 	unsigned int dvc;    /* De-emphasis and Volume Control */
 	unsigned int left, right;
 	char name[SPICDS_NAMELEN];
-	struct mtx *lock;
+	struct mtx lock;
 };
 
 static void
@@ -149,7 +149,7 @@ spicds_create(device_t dev, void *devinfo, int num, spicds_ctrl ctrl)
 		return NULL;
 
 	snprintf(codec->name, SPICDS_NAMELEN, "%s:spicds%d", device_get_nameunit(dev), num);
-	codec->lock = snd_mtxcreate(codec->name, codec->name);
+	mtx_init(&codec->lock, codec->name, codec->name, MTX_DEF);
 	codec->dev = dev;
 	codec->ctrl = ctrl;
 	codec->devinfo = devinfo;
@@ -165,40 +165,40 @@ spicds_create(device_t dev, void *devinfo, int num, spicds_ctrl ctrl)
 void
 spicds_destroy(struct spicds_info *codec)
 {
-	snd_mtxfree(codec->lock);
+	mtx_destroy(&codec->lock);
 	free(codec, M_SPICDS);
 }
 
 void
 spicds_settype(struct spicds_info *codec, unsigned int type)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->type = type;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
 spicds_setcif(struct spicds_info *codec, unsigned int cif)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->cif = cif;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
 spicds_setformat(struct spicds_info *codec, unsigned int format)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->format = format;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
 spicds_setdvc(struct spicds_info *codec, unsigned int dvc)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->dvc = dvc;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
@@ -207,7 +207,7 @@ spicds_init(struct spicds_info *codec)
 #if(0)
 	device_printf(codec->dev, "spicds_init(codec)\n");
 #endif
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	if (codec->type == SPICDS_TYPE_AK4524 ||\
 	    codec->type == SPICDS_TYPE_AK4528) {
 		/* power off */
@@ -244,13 +244,13 @@ spicds_init(struct spicds_info *codec)
 		spicds_wrcd(codec, 0x00, 0x8f);		/* I2S, 24bit, power-up */
 	if (codec->type == SPICDS_TYPE_AK4396)
 		spicds_wrcd(codec, 0x00, 0x07);		/* I2S, 24bit, power-up */
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
 spicds_reinit(struct spicds_info *codec)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	if (codec->type != SPICDS_TYPE_WM8770) {
 		/* reset */
 		spicds_wrcd(codec, AK4524_RESET, 0);
@@ -265,7 +265,7 @@ spicds_reinit(struct spicds_info *codec)
 		/* AK4358 reinit */
 		/* AK4381 reinit */
 	}
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 void
@@ -274,7 +274,7 @@ spicds_set(struct spicds_info *codec, int dir, unsigned int left, unsigned int r
 #if(0)
 	device_printf(codec->dev, "spicds_set(codec, %d, %d, %d)\n", dir, left, right);
 #endif
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	if (left >= 100)
 		if ((codec->type == SPICDS_TYPE_AK4381) || \
 		(codec->type == SPICDS_TYPE_AK4396))
@@ -362,7 +362,7 @@ spicds_set(struct spicds_info *codec, int dir, unsigned int left, unsigned int r
                 spicds_wrcd(codec, AK4396_ROATT, right);
         }
 
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 }
 
 MODULE_DEPEND(snd_spicds, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);

sys/dev/sound/pci/t4dwave.c

@@ -99,7 +99,7 @@ struct tr_info {
 	int regtype, regid, irqid;
 	void *ih;
 
-	struct mtx *lock;
+	struct mtx lock;
 
 	u_int32_t hwchns;
 	u_int32_t playchns;
@@ -209,7 +209,7 @@ tr_rdcd(kobj_t obj, void *devinfo, int regno)
 	i = j = 0;
 
 	regno &= 0x7f;
-	snd_mtxlock(tr->lock);
+	mtx_lock(&tr->lock);
 	if (tr->type == ALI_PCI_ID) {
 		u_int32_t chk1, chk2;
 		j = trw;
@@ -229,7 +229,7 @@ tr_rdcd(kobj_t obj, void *devinfo, int regno)
 		for (i=TR_TIMEOUT_CDC; (i > 0) && (j & trw); i--)
 		       	j=tr_rd(tr, treg, 4);
 	}
-	snd_mtxunlock(tr->lock);
+	mtx_unlock(&tr->lock);
 	if (i == 0) printf("codec timeout during read of register %x\n", regno);
 	return (j >> TR_CDC_DATA) & 0xffff;
 }
@@ -266,7 +266,7 @@ tr_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 	printf("tr_wrcd: reg %x was %x", regno, tr_rdcd(devinfo, regno));
 #endif
 	j=trw;
-	snd_mtxlock(tr->lock);
+	mtx_lock(&tr->lock);
 	if (tr->type == ALI_PCI_ID) {
 		j = trw;
 		for (i = TR_TIMEOUT_CDC; (i > 0) && (j & trw); i--)
@@ -290,7 +290,7 @@ tr_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 #if 0
 	printf(" - wrote %x, now %x\n", data, tr_rdcd(devinfo, regno));
 #endif
-	snd_mtxunlock(tr->lock);
+	mtx_unlock(&tr->lock);
 	if (i==0) printf("codec timeout writing %x, data %x\n", regno, data);
 	return (i > 0)? 0 : -1;
 }
@@ -336,7 +336,7 @@ tr_enaint(struct tr_chinfo *ch, int enable)
        	u_int32_t i, reg;
 	int bank, chan;
 
-	snd_mtxlock(tr->lock);
+	mtx_lock(&tr->lock);
 	bank = (ch->index & 0x20) ? 1 : 0;
 	chan = ch->index & 0x1f;
 	reg = bank? TR_REG_INTENB : TR_REG_INTENA;
@@ -347,7 +347,7 @@ tr_enaint(struct tr_chinfo *ch, int enable)
 
 	tr_clrint(ch);
 	tr_wr(tr, reg, i, 4);
-	snd_mtxunlock(tr->lock);
+	mtx_unlock(&tr->lock);
 }
 
 /* playback channels */
@@ -429,11 +429,11 @@ tr_wrch(struct tr_chinfo *ch)
 		cr[3]|=(ch->alpha<<20) | (ch->fms<<16) | (ch->fmc<<14);
 		break;
 	}
-	snd_mtxlock(tr->lock);
+	mtx_lock(&tr->lock);
 	tr_selch(ch);
 	for (i=0; i<TR_CHN_REGS; i++)
 		tr_wr(tr, TR_REG_CHNBASE+(i<<2), cr[i], 4);
-	snd_mtxunlock(tr->lock);
+	mtx_unlock(&tr->lock);
 }
 
 static void
@@ -442,11 +442,11 @@ tr_rdch(struct tr_chinfo *ch)
 	struct tr_info *tr = ch->parent;
 	u_int32_t cr[5], i;
 
-	snd_mtxlock(tr->lock);
+	mtx_lock(&tr->lock);
 	tr_selch(ch);
 	for (i=0; i<5; i++)
 		cr[i]=tr_rd(tr, TR_REG_CHNBASE+(i<<2), 4);
-	snd_mtxunlock(tr->lock);
+	mtx_unlock(&tr->lock);
 
 	if (tr->type == ALI_PCI_ID)
 		ch->lba=(cr[1] & ALI_MAXADDR);
@@ -830,7 +830,8 @@ tr_pci_attach(device_t dev)
 	tr = malloc(sizeof(*tr), M_DEVBUF, M_WAITOK | M_ZERO);
 	tr->type = pci_get_devid(dev);
 	tr->rev = pci_get_revid(dev);
-	tr->lock = snd_mtxcreate(device_get_nameunit(dev), "snd_t4dwave softc");
+	mtx_init(&tr->lock, device_get_nameunit(dev), "snd_t4dwave softc",
+	    MTX_DEF);
 
 	if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 	    "dac", &i) == 0) {
@@ -936,7 +937,7 @@ tr_pci_attach(device_t dev)
 	if (tr->ih) bus_teardown_intr(dev, tr->irq, tr->ih);
 	if (tr->irq) bus_release_resource(dev, SYS_RES_IRQ, tr->irqid, tr->irq);
 	if (tr->parent_dmat) bus_dma_tag_destroy(tr->parent_dmat);
-	if (tr->lock) snd_mtxfree(tr->lock);
+	mtx_destroy(&tr->lock);
 	free(tr, M_DEVBUF);
 	return ENXIO;
 }
@@ -956,7 +957,7 @@ tr_pci_detach(device_t dev)
 	bus_teardown_intr(dev, tr->irq, tr->ih);
 	bus_release_resource(dev, SYS_RES_IRQ, tr->irqid, tr->irq);
 	bus_dma_tag_destroy(tr->parent_dmat);
-	snd_mtxfree(tr->lock);
+	mtx_destroy(&tr->lock);
 	free(tr, M_DEVBUF);
 
 	return 0;

sys/dev/sound/pci/via8233.c

@@ -121,7 +121,7 @@ struct via_info {
 	uint16_t codec_caps;
 	uint16_t n_dxs_registered;
 	int play_num, rec_num;
-	struct mtx *lock;
+	struct mtx lock;
 	struct callout poll_timer;
 	int poll_ticks, polling;
 };
@@ -164,9 +164,9 @@ sysctl_via8233_spdif_enable(SYSCTL_HANDLER_ARGS)
 
 	dev = oidp->oid_arg1;
 	via = pcm_getdevinfo(dev);
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	r = pci_read_config(dev, VIA_PCI_SPDIF, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 	new_en = (r & VIA_SPDIF_EN) ? 1 : 0;
 	err = sysctl_handle_int(oidp, &new_en, 0, req);
 
@@ -179,9 +179,9 @@ sysctl_via8233_spdif_enable(SYSCTL_HANDLER_ARGS)
 		r |= VIA_SPDIF_EN;
 	else
 		r &= ~VIA_SPDIF_EN;
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	pci_write_config(dev, VIA_PCI_SPDIF, r, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (0);
 }
@@ -195,9 +195,9 @@ sysctl_via8233_dxs_src(SYSCTL_HANDLER_ARGS)
 
 	dev = oidp->oid_arg1;
 	via = pcm_getdevinfo(dev);
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	val = via->dxs_src;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 	err = sysctl_handle_int(oidp, &val, 0, req);
 
 	if (err || req->newptr == NULL)
@@ -205,9 +205,9 @@ sysctl_via8233_dxs_src(SYSCTL_HANDLER_ARGS)
 	if (val < 0 || val > 1)
 		return (EINVAL);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via->dxs_src = val;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (0);
 }
@@ -223,9 +223,9 @@ sysctl_via_polling(SYSCTL_HANDLER_ARGS)
 	via = pcm_getdevinfo(dev);
 	if (via == NULL)
 		return (EINVAL);
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	val = via->polling;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 	err = sysctl_handle_int(oidp, &val, 0, req);
 
 	if (err || req->newptr == NULL)
@@ -233,7 +233,7 @@ sysctl_via_polling(SYSCTL_HANDLER_ARGS)
 	if (val < 0 || val > 1)
 		return (EINVAL);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (val != via->polling) {
 		if (via_chan_active(via) != 0)
 			err = EBUSY;
@@ -242,7 +242,7 @@ sysctl_via_polling(SYSCTL_HANDLER_ARGS)
 		else
 			via->polling = 1;
 	}
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (err);
 }
@@ -411,9 +411,9 @@ via8233wr_setformat(kobj_t obj, void *data, uint32_t format)
 		f |= WR_FORMAT_STEREO;
 	if (format & AFMT_S16_LE)
 		f |= WR_FORMAT_16BIT;
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via_wr(via, VIA_WR0_FORMAT, f, 4);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (0);
 }
@@ -426,7 +426,7 @@ via8233dxs_setformat(kobj_t obj, void *data, uint32_t format)
 	uint32_t r, v;
 
 	r = ch->rbase + VIA8233_RP_DXS_RATEFMT;
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	v = via_rd(via, r, 4);
 
 	v &= ~(VIA8233_DXS_RATEFMT_STEREO | VIA8233_DXS_RATEFMT_16BIT);
@@ -435,7 +435,7 @@ via8233dxs_setformat(kobj_t obj, void *data, uint32_t format)
 	if (format & AFMT_16BIT)
 		v |= VIA8233_DXS_RATEFMT_16BIT;
 	via_wr(via, r, v, 4);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (0);
 }
@@ -457,10 +457,10 @@ via8233msgd_setformat(kobj_t obj, void *data, uint32_t format)
 		s |= SLOT3(1) | SLOT4(1);
 	}
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via_wr(via, VIA_MC_SLOT_SELECT, s, 4);
 	via_wr(via, VIA_MC_SGD_FORMAT, v, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (0);
 }
@@ -488,14 +488,14 @@ via8233dxs_setspeed(kobj_t obj, void *data, uint32_t speed)
 	uint32_t r, v;
 
 	r = ch->rbase + VIA8233_RP_DXS_RATEFMT;
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	v = via_rd(via, r, 4) & ~VIA8233_DXS_RATEFMT_48K;
 
 	/* Careful to avoid overflow (divide by 48 per vt8233c docs) */
 
 	v |= VIA8233_DXS_RATEFMT_48K * (speed / 48) / (48000 / 48);
 	via_wr(via, r, v, 4);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (speed);
 }
@@ -616,13 +616,13 @@ via8233chan_getptr(kobj_t obj, void *data)
 	struct via_info *via = ch->parent;
 	uint32_t v, index, count, ptr;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (via->polling != 0) {
 		ptr = ch->ptr;
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 	} else {
 		v = via_rd(via, ch->rbase + VIA_RP_CURRENT_COUNT, 4);
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		index = v >> 24;		/* Last completed buffer */
 		count = v & 0x00ffffff;	/* Bytes remaining */
 		ptr = (index + 1) * ch->blksz - count;
@@ -660,7 +660,7 @@ via8233wr_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	struct via_chinfo *ch;
 	int num;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	num = via->rec_num++;
 	ch = &via->rch[num];
 	ch->parent = via;
@@ -670,15 +670,15 @@ via8233wr_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	ch->blkcnt = via->blkcnt;
 	ch->rbase = VIA_WR_BASE(num);
 	via_wr(via, ch->rbase + VIA_WR_RP_SGD_FORMAT, WR_FIFO_ENABLE, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	if (sndbuf_alloc(ch->buffer, via->parent_dmat, 0, via->bufsz) != 0)
 		return (NULL);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via8233chan_sgdinit(via, ch, num);
 	via8233chan_reset(via, ch);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (ch);
 }
@@ -691,7 +691,7 @@ via8233dxs_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	struct via_chinfo *ch;
 	int num;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	num = via->play_num++;
 	ch = &via->pch[num];
 	ch->parent = via;
@@ -707,15 +707,15 @@ via8233dxs_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	 */
 	ch->rbase = VIA_DXS_BASE(NDXSCHANS - 1 - via->n_dxs_registered);
 	via->n_dxs_registered++;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	if (sndbuf_alloc(ch->buffer, via->parent_dmat, 0, via->bufsz) != 0)
 		return (NULL);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via8233chan_sgdinit(via, ch, NWRCHANS + num);
 	via8233chan_reset(via, ch);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (ch);
 }
@@ -728,7 +728,7 @@ via8233msgd_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	struct via_chinfo *ch;
 	int num;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	num = via->play_num++;
 	ch = &via->pch[num];
 	ch->parent = via;
@@ -737,15 +737,15 @@ via8233msgd_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
 	ch->dir = dir;
 	ch->rbase = VIA_MC_SGD_STATUS;
 	ch->blkcnt = via->blkcnt;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	if (sndbuf_alloc(ch->buffer, via->parent_dmat, 0, via->bufsz) != 0)
 		return (NULL);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	via8233chan_sgdinit(via, ch, NWRCHANS + num);
 	via8233chan_reset(via, ch);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return (ch);
 }
@@ -807,9 +807,9 @@ via_poll_callback(void *arg)
 	if (via == NULL)
 		return;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (via->polling == 0 || via_chan_active(via) == 0) {
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		return;
 	}
 
@@ -825,7 +825,7 @@ via_poll_callback(void *arg)
 	callout_reset(&via->poll_timer, 1/*via->poll_ticks*/,
 	    via_poll_callback, via);
 
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	for (i = 0; i < NDXSCHANS + NMSGDCHANS; i++) {
 		if (ptrigger & (1 << i))
@@ -888,7 +888,7 @@ via8233chan_trigger(kobj_t obj, void* data, int go)
 	if (!PCMTRIG_COMMON(go))
 		return (0);
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	switch(go) {
 	case PCMTRIG_START:
 		via_buildsgdt(ch);
@@ -957,7 +957,7 @@ via8233chan_trigger(kobj_t obj, void* data, int go)
 	default:
 		break;
 	}
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 	return (0);
 }
 
@@ -1009,9 +1009,9 @@ via_intr(void *p)
 	uint32_t ptrigger = 0, rtrigger = 0;
 	int i, reg, stat;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (via->polling != 0) {
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		return;
 	}
 	/* Poll playback channels */
@@ -1046,7 +1046,7 @@ via_intr(void *p)
 			rtrigger |= 1 << i;
 		}
 	}
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	for (i = 0; i < NDXSCHANS + NMSGDCHANS; i++) {
 		if (ptrigger & (1 << i))
@@ -1168,8 +1168,8 @@ via_attach(device_t dev)
 	uint32_t revid;
 
 	via = malloc(sizeof *via, M_DEVBUF, M_WAITOK | M_ZERO);
-	via->lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&via->lock, device_get_nameunit(dev), "snd_via8233 softc",
-	    "snd_via8233 softc");
+	    MTX_DEF);
 	via->dev = dev;
 
 	callout_init(&via->poll_timer, 1);
@@ -1384,8 +1384,7 @@ via_attach(device_t dev)
 		bus_dmamem_free(via->sgd_dmat, via->sgd_table, via->sgd_dmamap);
 	if (via->sgd_dmat)
 		bus_dma_tag_destroy(via->sgd_dmat);
-	if (via->lock)
+	mtx_destroy(&via->lock);
-		snd_mtxfree(via->lock);
 	if (via)
 		free(via, M_DEVBUF);
 	return (ENXIO);
@@ -1404,10 +1403,10 @@ via_detach(device_t dev)
 	via = pcm_getdevinfo(dev);
 
 	if (via != NULL && (via->play_num != 0 || via->rec_num != 0)) {
-		snd_mtxlock(via->lock);
+		mtx_lock(&via->lock);
 		via->polling = 0;
 		callout_stop(&via->poll_timer);
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		callout_drain(&via->poll_timer);
 	}
 
@@ -1418,7 +1417,7 @@ via_detach(device_t dev)
 	bus_dmamap_unload(via->sgd_dmat, via->sgd_dmamap);
 	bus_dmamem_free(via->sgd_dmat, via->sgd_table, via->sgd_dmamap);
 	bus_dma_tag_destroy(via->sgd_dmat);
-	snd_mtxfree(via->lock);
+	mtx_destroy(&via->lock);
 	free(via, M_DEVBUF);
 	return (0);
 }

sys/dev/sound/pci/via82c686.c

@@ -90,7 +90,7 @@ struct via_info {
 	struct via_chinfo pch, rch;
 	struct via_dma_op *sgd_table;
 	u_int16_t codec_caps;
-	struct mtx *lock;
+	struct mtx lock;
 };
 
 static u_int32_t via_fmt[] = {
@@ -245,7 +245,7 @@ viachan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *
 	struct via_info *via = devinfo;
 	struct via_chinfo *ch;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (dir == PCMDIR_PLAY) {
 		ch = &via->pch;
 		ch->base = VIA_PLAY_DMAOPS_BASE;
@@ -268,7 +268,7 @@ viachan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *
 	ch->channel = c;
 	ch->buffer = b;
 	ch->dir = dir;
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	if (sndbuf_alloc(ch->buffer, via->parent_dmat, 0, via->bufsz) != 0)
 		return NULL;
@@ -290,12 +290,12 @@ viachan_setformat(kobj_t obj, void *data, u_int32_t format)
 		mode_set |= VIA_RPMODE_16BIT;
 
 	DEB(printf("set format: dir = %d, format=%x\n", ch->dir, format));
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	mode = via_rd(via, ch->mode, 1);
 	mode &= ~(VIA_RPMODE_16BIT | VIA_RPMODE_STEREO);
 	mode |= mode_set;
 	via_wr(via, ch->mode, mode, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	return 0;
 }
@@ -346,14 +346,14 @@ viachan_trigger(kobj_t obj, void *data, int go)
 
 	DEB(printf("ado located at va=%p pa=%x\n", ch->sgd_table, sgd_addr));
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (go == PCMTRIG_START) {
 		via_buildsgdt(ch);
 		via_wr(via, ch->base, sgd_addr, 4);
 		via_wr(via, ch->ctrl, VIA_RPCTRL_START, 1);
 	} else
 		via_wr(via, ch->ctrl, VIA_RPCTRL_TERMINATE, 1);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	DEB(printf("viachan_trigger: go=%d\n", go));
 	return 0;
@@ -367,13 +367,13 @@ viachan_getptr(kobj_t obj, void *data)
 	bus_addr_t sgd_addr = ch->sgd_addr;
 	u_int32_t ptr, base, base1, len, seg;
 
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	base1 = via_rd(via, ch->base, 4);
 	len = via_rd(via, ch->count, 4);
 	base = via_rd(via, ch->base, 4);
 	if (base != base1) 	/* Avoid race hazard */
 		len = via_rd(via, ch->count, 4);
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 
 	DEB(printf("viachan_getptr: len / base = %x / %x\n", len, base));
 
@@ -426,22 +426,22 @@ via_intr(void *p)
 
 	/* DEB(printf("viachan_intr\n")); */
 	/* Read channel */
-	snd_mtxlock(via->lock);
+	mtx_lock(&via->lock);
 	if (via_rd(via, VIA_PLAY_STAT, 1) & VIA_RPSTAT_INTR) {
 		via_wr(via, VIA_PLAY_STAT, VIA_RPSTAT_INTR, 1);
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		chn_intr(via->pch.channel);
-		snd_mtxlock(via->lock);
+		mtx_lock(&via->lock);
 	}
 
 	/* Write channel */
 	if (via_rd(via, VIA_RECORD_STAT, 1) & VIA_RPSTAT_INTR) {
 		via_wr(via, VIA_RECORD_STAT, VIA_RPSTAT_INTR, 1);
-		snd_mtxunlock(via->lock);
+		mtx_unlock(&via->lock);
 		chn_intr(via->rch.channel);
 		return;
 	}
-	snd_mtxunlock(via->lock);
+	mtx_unlock(&via->lock);
 }
 
 /*
@@ -472,8 +472,8 @@ via_attach(device_t dev)
 	u_int32_t data, cnt;
 
 	via = malloc(sizeof(*via), M_DEVBUF, M_WAITOK | M_ZERO);
-	via->lock = snd_mtxcreate(device_get_nameunit(dev),
+	mtx_init(&via->lock, device_get_nameunit(dev), "snd_via82c686 softc",
-	    "snd_via82c686 softc");
+	    MTX_DEF);
 
 	pci_enable_busmaster(dev);
 
@@ -600,7 +600,7 @@ via_attach(device_t dev)
 	if (via->sgd_addr) bus_dmamap_unload(via->sgd_dmat, via->sgd_dmamap);
 	if (via->sgd_table) bus_dmamem_free(via->sgd_dmat, via->sgd_table, via->sgd_dmamap);
 	if (via->sgd_dmat) bus_dma_tag_destroy(via->sgd_dmat);
-	if (via->lock) snd_mtxfree(via->lock);
+	mtx_destroy(&via->lock);
 	if (via) free(via, M_DEVBUF);
 	return ENXIO;
 }
@@ -623,7 +623,7 @@ via_detach(device_t dev)
 	bus_dmamap_unload(via->sgd_dmat, via->sgd_dmamap);
 	bus_dmamem_free(via->sgd_dmat, via->sgd_table, via->sgd_dmamap);
 	bus_dma_tag_destroy(via->sgd_dmat);
-	snd_mtxfree(via->lock);
+	mtx_destroy(&via->lock);
 	free(via, M_DEVBUF);
 	return 0;
 }

sys/dev/sound/pcm/ac97.c

@@ -65,7 +65,7 @@ struct ac97_info {
 	u_int32_t flags;
 	struct ac97mixtable_entry mix[AC97_MIXER_SIZE];
 	char name[16];
-	struct mtx *lock;
+	struct mtx lock;
 };
 
 struct ac97_vendorid {
@@ -364,7 +364,7 @@ ac97_setrate(struct ac97_info *codec, int which, int rate)
 		return -1;
 	}
 
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	if (rate != 0) {
 		v = rate;
 		if (codec->extstat & AC97_EXTCAP_DRA)
@@ -374,7 +374,7 @@ ac97_setrate(struct ac97_info *codec, int which, int rate)
 	v = ac97_rdcd(codec, which);
 	if (codec->extstat & AC97_EXTCAP_DRA)
 		v <<= 1;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	return v;
 }
 
@@ -387,10 +387,10 @@ ac97_setextmode(struct ac97_info *codec, u_int16_t mode)
 			      mode);
 		return -1;
 	}
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	ac97_wrcd(codec, AC97_REGEXT_STAT, mode);
 	codec->extstat = ac97_rdcd(codec, AC97_REGEXT_STAT) & AC97_EXTCAPS;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	return (mode == codec->extstat)? 0 : -1;
 }
 
@@ -426,9 +426,9 @@ ac97_setrecsrc(struct ac97_info *codec, int channel)
 	if (e->recidx > 0) {
 		int val = e->recidx - 1;
 		val |= val << 8;
-		snd_mtxlock(codec->lock);
+		mtx_lock(&codec->lock);
 		ac97_wrcd(codec, AC97_REG_RECSEL, val);
-		snd_mtxunlock(codec->lock);
+		mtx_unlock(&codec->lock);
 		return 0;
 	} else
 		return -1;
@@ -497,13 +497,13 @@ ac97_setmixer(struct ac97_info *codec, unsigned channel, unsigned left, unsigned
 		/*
 		 * If the mask bit is set, do not alter the other bits.
 		 */
-		snd_mtxlock(codec->lock);
+		mtx_lock(&codec->lock);
 		if (e->mask) {
 			int cur = ac97_rdcd(codec, reg);
 			val |= cur & ~(mask);
 		}
 		ac97_wrcd(codec, reg, val);
-		snd_mtxunlock(codec->lock);
+		mtx_unlock(&codec->lock);
 		return left | (right << 8);
 	} else {
 		return -1;
@@ -603,11 +603,11 @@ ac97_initmixer(struct ac97_info *codec)
 	u_int32_t id;
 	int reg;
 
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->count = AC97_INIT(codec->methods, codec->devinfo);
 	if (codec->count == 0) {
 		device_printf(codec->dev, "ac97 codec init failed\n");
-		snd_mtxunlock(codec->lock);
+		mtx_unlock(&codec->lock);
 		return ENODEV;
 	}
 
@@ -633,7 +633,7 @@ ac97_initmixer(struct ac97_info *codec)
 	id = (ac97_rdcd(codec, AC97_REG_ID1) << 16) | ac97_rdcd(codec, AC97_REG_ID2);
 	if (id == 0 || id == 0xffffffff) {
 		device_printf(codec->dev, "ac97 codec invalid or not present (id == %x)\n", id);
-		snd_mtxunlock(codec->lock);
+		mtx_unlock(&codec->lock);
 		return ENODEV;
 	}
 
@@ -780,18 +780,18 @@ ac97_initmixer(struct ac97_info *codec)
 	}
 	if (bootverbose)
 		device_printf(codec->dev, "ac97 codec dac ready count: %d\n", i);
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	return 0;
 }
 
 static unsigned
 ac97_reinitmixer(struct ac97_info *codec)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	codec->count = AC97_INIT(codec->methods, codec->devinfo);
 	if (codec->count == 0) {
 		device_printf(codec->dev, "ac97 codec init failed\n");
-		snd_mtxunlock(codec->lock);
+		mtx_unlock(&codec->lock);
 		return ENODEV;
 	}
 
@@ -811,7 +811,7 @@ ac97_reinitmixer(struct ac97_info *codec)
 
 	if ((ac97_rdcd(codec, AC97_REG_POWER) & 2) == 0)
 		device_printf(codec->dev, "ac97 codec reports dac not ready\n");
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	return 0;
 }
 
@@ -824,7 +824,7 @@ ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
 	codec = malloc(sizeof(*codec), M_AC97, M_WAITOK | M_ZERO);
 	snprintf(codec->name, sizeof(codec->name), "%s:ac97",
 	    device_get_nameunit(dev));
-	codec->lock = snd_mtxcreate(codec->name, "ac97 codec");
+	mtx_init(&codec->lock, codec->name, "ac97 codec", MTX_DEF);
 	codec->methods = kobj_create(cls, M_AC97, M_WAITOK | M_ZERO);
 	codec->dev = dev;
 	codec->devinfo = devinfo;
@@ -844,10 +844,10 @@ ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
 void
 ac97_destroy(struct ac97_info *codec)
 {
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	if (codec->methods != NULL)
 		kobj_delete(codec->methods, M_AC97);
-	snd_mtxfree(codec->lock);
+	mtx_destroy(&codec->lock);
 	free(codec, M_AC97);
 }
 
@@ -960,21 +960,21 @@ sysctl_hw_snd_ac97_eapd(SYSCTL_HANDLER_ARGS)
 	u_int16_t val;
 
 	codec = oidp->oid_arg1;
-	if (codec == NULL || codec->id == 0 || codec->lock == NULL)
+	if (codec == NULL || codec->id == 0)
 		return EINVAL;
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	val = ac97_rdcd(codec, AC97_REG_POWER);
 	inv = (codec->flags & AC97_F_EAPD_INV) ? 0 : 1;
 	ea = (val >> 15) ^ inv;
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	err = sysctl_handle_int(oidp, &ea, 0, req);
 	if (err == 0 && req->newptr != NULL) {
 		if (ea != 0 && ea != 1)
 			return EINVAL;
 		if (ea != ((val >> 15) ^ inv)) {
-			snd_mtxlock(codec->lock);
+			mtx_lock(&codec->lock);
 			ac97_wrcd(codec, AC97_REG_POWER, val ^ 0x8000);
-			snd_mtxunlock(codec->lock);
+			mtx_unlock(&codec->lock);
 		}
 	}
 	return err;
@@ -987,12 +987,12 @@ ac97_init_sysctl(struct ac97_info *codec)
 
 	if (codec == NULL || codec->dev == NULL)
 		return;
-	snd_mtxlock(codec->lock);
+	mtx_lock(&codec->lock);
 	orig = ac97_rdcd(codec, AC97_REG_POWER);
 	ac97_wrcd(codec, AC97_REG_POWER, orig ^ 0x8000);
 	val = ac97_rdcd(codec, AC97_REG_POWER);
 	ac97_wrcd(codec, AC97_REG_POWER, orig);
-	snd_mtxunlock(codec->lock);
+	mtx_unlock(&codec->lock);
 	if ((val & 0x8000) == (orig & 0x8000))
 		return;
 	SYSCTL_ADD_PROC(device_get_sysctl_ctx(codec->dev),

sys/dev/sound/pcm/channel.c

@@ -228,19 +228,21 @@ chn_lockinit(struct pcm_channel *c, int dir)
 {
 	switch (dir) {
 	case PCMDIR_PLAY:
-		c->lock = snd_mtxcreate(c->name, "pcm play channel");
+		mtx_init(&c->lock, c->name, "pcm play channel", MTX_DEF);
 		cv_init(&c->intr_cv, "pcmwr");
 		break;
 	case PCMDIR_PLAY_VIRTUAL:
-		c->lock = snd_mtxcreate(c->name, "pcm virtual play channel");
+		mtx_init(&c->lock, c->name, "pcm virtual play channel",
+		    MTX_DEF);
 		cv_init(&c->intr_cv, "pcmwrv");
 		break;
 	case PCMDIR_REC:
-		c->lock = snd_mtxcreate(c->name, "pcm record channel");
+		mtx_init(&c->lock, c->name, "pcm record channel", MTX_DEF);
 		cv_init(&c->intr_cv, "pcmrd");
 		break;
 	case PCMDIR_REC_VIRTUAL:
-		c->lock = snd_mtxcreate(c->name, "pcm virtual record channel");
+		mtx_init(&c->lock, c->name, "pcm virtual record channel",
+		    MTX_DEF);
 		cv_init(&c->intr_cv, "pcmrdv");
 		break;
 	default:
@@ -262,7 +264,7 @@ chn_lockdestroy(struct pcm_channel *c)
 	cv_destroy(&c->cv);
 	cv_destroy(&c->intr_cv);
 
-	snd_mtxfree(c->lock);
+	mtx_destroy(&c->lock);
 }
 
 /**
@@ -337,7 +339,7 @@ chn_sleep(struct pcm_channel *c, int timeout)
 		return (EINVAL);
 
 	c->sleeping++;
-	ret = cv_timedwait_sig(&c->intr_cv, c->lock, timeout);
+	ret = cv_timedwait_sig(&c->intr_cv, &c->lock, timeout);
 	c->sleeping--;
 
 	return ((c->flags & CHN_F_DEAD) ? EINVAL : ret);
@@ -1235,7 +1237,7 @@ chn_init(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls,
 	}
 	c->bufhard = b;
 	c->bufsoft = bs;
-	knlist_init_mtx(&bs->sel.si_note, c->lock);
+	knlist_init_mtx(&bs->sel.si_note, &c->lock);
 
 	c->devinfo = CHANNEL_INIT(c->methods, devinfo, b, c, direction);
 	if (c->devinfo == NULL) {

sys/dev/sound/pcm/channel.h

@@ -110,7 +110,7 @@ struct pcm_channel {
 	int type;
 	char name[CHN_NAMELEN];
 	char comm[MAXCOMLEN + 1];
-	struct mtx *lock;
+	struct mtx lock;
 	int trigger;
 	/**
 	 * For interrupt manipulations.
@@ -319,12 +319,12 @@ int chn_syncdestroy(struct pcm_channel *c);
 int chn_getpeaks(struct pcm_channel *c, int *lpeak, int *rpeak);
 #endif
 
-#define CHN_LOCKOWNED(c)	mtx_owned((c)->lock)
+#define CHN_LOCKOWNED(c)	mtx_owned(&(c)->lock)
-#define CHN_LOCK(c)		mtx_lock((c)->lock)
+#define CHN_LOCK(c)		mtx_lock(&(c)->lock)
-#define CHN_UNLOCK(c)		mtx_unlock((c)->lock)
+#define CHN_UNLOCK(c)		mtx_unlock(&(c)->lock)
-#define CHN_TRYLOCK(c)		mtx_trylock((c)->lock)
+#define CHN_TRYLOCK(c)		mtx_trylock(&(c)->lock)
-#define CHN_LOCKASSERT(c)	mtx_assert((c)->lock, MA_OWNED)
+#define CHN_LOCKASSERT(c)	mtx_assert(&(c)->lock, MA_OWNED)
-#define CHN_UNLOCKASSERT(c)	mtx_assert((c)->lock, MA_NOTOWNED)
+#define CHN_UNLOCKASSERT(c)	mtx_assert(&(c)->lock, MA_NOTOWNED)
 
 #define CHN_BROADCAST(x)	cv_broadcastpri(x, PRIBIO)
 

sys/dev/sound/pcm/dsp.c

@@ -1597,7 +1597,7 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
 			struct snd_dbuf *bs;
 			CHN_LOCK(wrch);
 			while (wrch->inprog != 0)
-				cv_wait(&wrch->cv, wrch->lock);
+				cv_wait(&wrch->cv, &wrch->lock);
 			bs = wrch->bufsoft;
 			if ((bs->shadbuf != NULL) && (sndbuf_getready(bs) > 0)) {
 				bs->sl = sndbuf_getready(bs);
@@ -1621,7 +1621,7 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
 			struct snd_dbuf *bs;
 			CHN_LOCK(wrch);
 			while (wrch->inprog != 0)
-				cv_wait(&wrch->cv, wrch->lock);
+				cv_wait(&wrch->cv, &wrch->lock);
 			bs = wrch->bufsoft;
 			if ((bs->shadbuf != NULL) && (bs->sl > 0)) {
 				sndbuf_softreset(bs);

sys/dev/sound/pcm/mixer.c

@@ -63,7 +63,7 @@ struct snd_mixer {
 	u_int32_t child[32];
 	u_int8_t realdev[32];
 	char name[MIXER_NAMELEN];
-	struct mtx *lock;
+	struct mtx lock;
 	oss_mixer_enuminfo enuminfo;
 	int modify_counter;
 };
@@ -126,12 +126,12 @@ mixer_lookup(char *devname)
 
 #define MIXER_SET_UNLOCK(x, y)		do {				\
 	if ((y) != 0)							\
-		snd_mtxunlock((x)->lock);				\
+		mtx_unlock(&(x)->lock);					\
 } while (0)
 
 #define MIXER_SET_LOCK(x, y)		do {				\
 	if ((y) != 0)							\
-		snd_mtxlock((x)->lock);					\
+		mtx_lock(&(x)->lock);					\
 } while (0)
 
 static int
@@ -144,12 +144,12 @@ mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d,
 	if (!PCM_REGISTERED(d))
 		return (EINVAL);
 
-	if (mtx_owned(m->lock))
+	if (mtx_owned(&m->lock))
 		dropmtx = 1;
 	else
 		dropmtx = 0;
 
-	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
+	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(&d->lock) != 0)
 		acquiremtx = 0;
 	else
 		acquiremtx = 1;
@@ -197,12 +197,12 @@ mixer_set_eq(struct snd_mixer *m, struct snddev_info *d,
 	if (!PCM_REGISTERED(d))
 		return (EINVAL);
 
-	if (mtx_owned(m->lock))
+	if (mtx_owned(&m->lock))
 		dropmtx = 1;
 	else
 		dropmtx = 0;
 
-	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0)
+	if (!(d->flags & SD_F_MPSAFE) || mtx_owned(&d->lock) != 0)
 		acquiremtx = 0;
 	else
 		acquiremtx = 1;
@@ -253,7 +253,7 @@ mixer_set(struct snd_mixer *m, u_int dev, u_int32_t muted, u_int lev)
 		return (-1);
 
 	/* It is safe to drop this mutex due to Giant. */
-	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0)
+	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(&m->lock) != 0)
 		dropmtx = 1;
 	else
 		dropmtx = 0;
@@ -367,7 +367,7 @@ mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
 	d = device_get_softc(mixer->dev);
 	if (d == NULL)
 		return -1;
-	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0)
+	if (!(d->flags & SD_F_MPSAFE) && mtx_owned(&mixer->lock) != 0)
 		dropmtx = 1;
 	else
 		dropmtx = 0;
@@ -647,8 +647,8 @@ mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo,
 		strlcat(m->name, ":", sizeof(m->name));
 		strlcat(m->name, desc, sizeof(m->name));
 	}
-	m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ?
+	mtx_init(&m->lock, m->name, (type == MIXER_TYPE_PRIMARY) ?
-	    "primary pcm mixer" : "secondary pcm mixer");
+	    "primary pcm mixer" : "secondary pcm mixer", MTX_DEF);
 	m->type = type;
 	m->devinfo = devinfo;
 	m->busy = 0;
@@ -660,8 +660,8 @@ mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo,
 	}
 
 	if (MIXER_INIT(m)) {
-		snd_mtxlock(m->lock);
+		mtx_lock(&m->lock);
-		snd_mtxfree(m->lock);
+		mtx_destroy(&m->lock);
 		kobj_delete((kobj_t)m, M_MIXER);
 		return (NULL);
 	}
@@ -680,7 +680,7 @@ mixer_delete(struct snd_mixer *m)
 
 	MIXER_UNINIT(m);
 
-	snd_mtxfree(m->lock);
+	mtx_destroy(&m->lock);
 	kobj_delete((kobj_t)m, M_MIXER);
 
 	return (0);
@@ -792,20 +792,20 @@ mixer_uninit(device_t dev)
 	pdev->si_drv1 = NULL;
 	destroy_dev(pdev);
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 
 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
 		mixer_set(m, i, 0, 0);
 
 	mixer_setrecsrc(m, SOUND_MASK_MIC);
 
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	/* mixer uninit can sleep --hps */
 
 	MIXER_UNINIT(m);
 
-	snd_mtxfree(m->lock);
+	mtx_destroy(&m->lock);
 	kobj_delete((kobj_t)m, M_MIXER);
 
 	d->mixer_dev = NULL;
@@ -822,11 +822,11 @@ mixer_reinit(device_t dev)
 
 	pdev = mixer_get_devt(dev);
 	m = pdev->si_drv1;
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 
 	i = MIXER_REINIT(m);
 	if (i) {
-		snd_mtxunlock(m->lock);
+		mtx_unlock(&m->lock);
 		return i;
 	}
 
@@ -838,7 +838,7 @@ mixer_reinit(device_t dev)
 	}
 
 	mixer_setrecsrc(m, m->recsrc);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return 0;
 }
@@ -851,21 +851,21 @@ sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
 	struct snd_mixer *m;
 
 	m = oidp->oid_arg1;
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	strlcpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 	error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	if (error == 0 && req->newptr != NULL) {
 		dev = mixer_lookup(devname);
 		if (dev == -1) {
-			snd_mtxunlock(m->lock);
+			mtx_unlock(&m->lock);
 			return EINVAL;
 		} else {
 			m->hwvol_mixer = dev;
 		}
 	}
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 	return error;
 }
 
@@ -904,9 +904,9 @@ mixer_hwvol_mute(device_t dev)
 
 	pdev = mixer_get_devt(dev);
 	m = pdev->si_drv1;
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	mixer_hwvol_mute_locked(m);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 }
 
 void
@@ -942,9 +942,9 @@ mixer_hwvol_step(device_t dev, int left_step, int right_step)
 
 	pdev = mixer_get_devt(dev);
 	m = pdev->si_drv1;
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	mixer_hwvol_step_locked(m, left_step, right_step);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 }
 
 int
@@ -962,9 +962,9 @@ mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right)
 
 	KASSERT(m != NULL, ("NULL snd_mixer"));
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	ret = mixer_set(m, dev, m->mutedevs, left | (right << 8));
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return ((ret != 0) ? ENXIO : 0);
 }
@@ -976,9 +976,9 @@ mix_get(struct snd_mixer *m, u_int dev)
 
 	KASSERT(m != NULL, ("NULL snd_mixer"));
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	ret = mixer_get(m, dev);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return (ret);
 }
@@ -990,9 +990,9 @@ mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
 
 	KASSERT(m != NULL, ("NULL snd_mixer"));
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	ret = mixer_setrecsrc(m, src);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return ((ret != 0) ? ENXIO : 0);
 }
@@ -1004,9 +1004,9 @@ mix_getrecsrc(struct snd_mixer *m)
 
 	KASSERT(m != NULL, ("NULL snd_mixer"));
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	ret = mixer_getrecsrc(m);
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return (ret);
 }
@@ -1037,9 +1037,9 @@ mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
 
 	/* XXX Need Giant magic entry ??? */
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	m->busy = 1;
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return (0);
 }
@@ -1061,10 +1061,10 @@ mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
 
 	/* XXX Need Giant magic entry ??? */
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	ret = (m->busy == 0) ? EBADF : 0;
 	m->busy = 0;
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 
 	return (ret);
 }
@@ -1142,9 +1142,9 @@ mixer_ioctl_channel(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
 	if ((j == SOUND_MIXER_DEVMASK || j == SOUND_MIXER_CAPS ||
 	    j == SOUND_MIXER_STEREODEVS) &&
 	    (cmd & ~0xff) == MIXER_READ(0)) {
-		snd_mtxlock(m->lock);
+		mtx_lock(&m->lock);
 		*(int *)arg = mix_getdevs(m);
-		snd_mtxunlock(m->lock);
+		mtx_unlock(&m->lock);
 		if (rdch != NULL)
 			*(int *)arg |= SOUND_MASK_RECLEV;
 		if (wrch != NULL)
@@ -1261,9 +1261,9 @@ mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
 	if (m == NULL)
 		return (EBADF);
 
-	snd_mtxlock(m->lock);
+	mtx_lock(&m->lock);
 	if (from == MIXER_CMD_CDEV && !m->busy) {
-		snd_mtxunlock(m->lock);
+		mtx_unlock(&m->lock);
 		return (EBADF);
 	}
 	switch (cmd) {
@@ -1299,7 +1299,7 @@ mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
 			ret = mixer_set(m, j, m->mutedevs, *arg_i);
 			break;
 		}
-		snd_mtxunlock(m->lock);
+		mtx_unlock(&m->lock);
 		return ((ret == 0) ? 0 : ENXIO);
 	}
 	if ((cmd & ~0xff) == MIXER_READ(0)) {
@@ -1323,11 +1323,11 @@ mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
 			break;
 		}
 		*arg_i = v;
-		snd_mtxunlock(m->lock);
+		mtx_unlock(&m->lock);
 		return ((v != -1) ? 0 : ENXIO);
 	}
 done:
-	snd_mtxunlock(m->lock);
+	mtx_unlock(&m->lock);
 	return (ret);
 }
 
@@ -1456,7 +1456,7 @@ mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
 		}
 
 		m = d->mixer_dev->si_drv1;
-		mtx_lock(m->lock);
+		mtx_lock(&m->lock);
 
 		/*
 		 * At this point, the following synchronization stuff
@@ -1533,7 +1533,7 @@ mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
 		snprintf(mi->devnode, sizeof(mi->devnode), "/dev/mixer%d", i);
 		mi->legacy_device = i;
 
-		mtx_unlock(m->lock);
+		mtx_unlock(&m->lock);
 
 		PCM_UNLOCK(d);
 
@@ -1552,8 +1552,5 @@ mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi)
 struct mtx *
 mixer_get_lock(struct snd_mixer *m)
 {
-	if (m->lock == NULL) {
+	return (&m->lock);
-		return (&Giant);
-	}
-	return (m->lock);
 }

sys/dev/sound/pcm/sound.c

@@ -62,35 +62,6 @@ SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
  */
 struct unrhdr *pcmsg_unrhdr = NULL;
 
-void *
-snd_mtxcreate(const char *desc, const char *type)
-{
-	struct mtx *m;
-
-	m = malloc(sizeof(*m), M_DEVBUF, M_WAITOK | M_ZERO);
-	mtx_init(m, desc, type, MTX_DEF);
-	return m;
-}
-
-void
-snd_mtxfree(void *m)
-{
-	struct mtx *mtx = m;
-
-	mtx_destroy(mtx);
-	free(mtx, M_DEVBUF);
-}
-
-void
-snd_mtxassert(void *m)
-{
-#ifdef INVARIANTS
-	struct mtx *mtx = m;
-
-	mtx_assert(mtx, MA_OWNED);
-#endif
-}
-
 int
 snd_setup_intr(device_t dev, struct resource *res, int flags, driver_intr_t hand, void *param, void **cookiep)
 {
@@ -361,7 +332,7 @@ pcm_init(device_t dev, void *devinfo)
 
 	d = device_get_softc(dev);
 	d->dev = dev;
-	d->lock = snd_mtxcreate(device_get_nameunit(dev), "sound cdev");
+	mtx_init(&d->lock, device_get_nameunit(dev), "sound cdev", MTX_DEF);
 	cv_init(&d->cv, device_get_nameunit(dev));
 
 	i = 0;
@@ -498,7 +469,7 @@ pcm_unregister(device_t dev)
 	dsp_destroy_dev(dev);
 
 	cv_destroy(&d->cv);
-	snd_mtxfree(d->lock);
+	mtx_destroy(&d->lock);
 
 	if (snd_unit == device_get_unit(dev)) {
 		snd_unit = pcm_best_unit(-1);

sys/dev/sound/pcm/sound.h

@@ -134,7 +134,7 @@ struct snd_mixer;
 				"\016RVCHANS"
 
 #define PCM_REGISTERED(x)	\
-	((x) != NULL && (x)->lock != NULL && ((x)->flags & SD_F_REGISTERED))
+	((x) != NULL && ((x)->flags & SD_F_REGISTERED))
 
 #define	PCM_MAXCHANS		10000
 #define	PCM_CHANCOUNT(d)	\
@@ -167,12 +167,6 @@ void *pcm_getdevinfo(device_t dev);
 int snd_setup_intr(device_t dev, struct resource *res, int flags,
 		   driver_intr_t hand, void *param, void **cookiep);
 
-void *snd_mtxcreate(const char *desc, const char *type);
-void snd_mtxfree(void *m);
-void snd_mtxassert(void *m);
-#define	snd_mtxlock(m) mtx_lock(m)
-#define	snd_mtxunlock(m) mtx_unlock(m)
-
 int sndstat_register(device_t dev, char *str);
 int sndstat_unregister(device_t dev);
 
@@ -218,7 +212,7 @@ struct snddev_info {
 	void *devinfo;
 	device_t dev;
 	char status[SND_STATUSLEN];
-	struct mtx *lock;
+	struct mtx lock;
 	struct cdev *mixer_dev;
 	struct cdev *dsp_dev;
 	uint32_t pvchanrate, pvchanformat, pvchanmode;
@@ -240,12 +234,12 @@ int	sound_oss_card_info(oss_card_info *);
 #define	PCM_MODE_PLAY		0x02
 #define	PCM_MODE_REC		0x04
 
-#define PCM_LOCKOWNED(d)	mtx_owned((d)->lock)
+#define PCM_LOCKOWNED(d)	mtx_owned(&(d)->lock)
-#define	PCM_LOCK(d)		mtx_lock((d)->lock)
+#define	PCM_LOCK(d)		mtx_lock(&(d)->lock)
-#define	PCM_UNLOCK(d)		mtx_unlock((d)->lock)
+#define	PCM_UNLOCK(d)		mtx_unlock(&(d)->lock)
-#define PCM_TRYLOCK(d)		mtx_trylock((d)->lock)
+#define PCM_TRYLOCK(d)		mtx_trylock(&(d)->lock)
-#define PCM_LOCKASSERT(d)	mtx_assert((d)->lock, MA_OWNED)
+#define PCM_LOCKASSERT(d)	mtx_assert(&(d)->lock, MA_OWNED)
-#define PCM_UNLOCKASSERT(d)	mtx_assert((d)->lock, MA_NOTOWNED)
+#define PCM_UNLOCKASSERT(d)	mtx_assert(&(d)->lock, MA_NOTOWNED)
 
 /*
  * For PCM_[WAIT | ACQUIRE | RELEASE], be sure to surround these
@@ -254,7 +248,7 @@ int	sound_oss_card_info(oss_card_info *);
 #define PCM_WAIT(x)		do {					\
 	PCM_LOCKASSERT(x);						\
 	while ((x)->flags & SD_F_BUSY)					\
-		cv_wait(&(x)->cv, (x)->lock);				\
+		cv_wait(&(x)->cv, &(x)->lock);				\
 } while (0)
 
 #define PCM_ACQUIRE(x)		do {					\

sys/dev/sound/usb/uaudio.c

@@ -2664,7 +2664,7 @@ uaudio_chan_init(struct uaudio_chan *ch, struct snd_dbuf *b,
 	/* store mutex and PCM channel */
 
 	ch->pcm_ch = c;
-	ch->pcm_mtx = c->lock;
+	ch->pcm_mtx = &c->lock;
 
 	/* compute worst case buffer */