kgess-mirror/freebsd-src
1
0
Fork 0
mirror of https://git.freebsd.org/src.git synced 2026-01-16 23:02:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

sound: Retire snd_mtx* wrappers

Browse source 
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
This commit is contained in:
Christos Margiolis 2025-11-21 17:14:33 +01:00
parent e254ef87a3
commit 9d18115ca0
37 changed files with 537 additions and 581 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
sys/arm/allwinner/a10_codec.c
View file

@ -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);

20
sys/arm/freescale/imx/imx6_ssi.c
View file

@ -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);

20
sys/arm/freescale/vybrid/vf_sai.c
View file

@ -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);

29
sys/dev/sound/dummy.c
View file

@ -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");
callout_init_mtx(&sc->callout, sc->lock, 0);
mtx_init(&sc->lock, device_get_nameunit(dev), "snd_dummy softc",
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);
}

50
sys/dev/sound/pci/als4000.c
View file

@ -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) {
snd_mtxfree(sc->lock);
sc->lock = NULL;
}
mtx_destroy(&sc->lock);
}
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;
}

18
sys/dev/sound/pci/atiixp.c
View file

@ -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_unlock(_sc) snd_mtxunlock((_sc)->lock)
#define atiixp_assert(_sc) snd_mtxassert((_sc)->lock)
#define atiixp_lock(_sc) mtx_lock(&(_sc)->lock)
#define atiixp_unlock(_sc) mtx_unlock(&(_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) {
snd_mtxfree(sc->lock);
sc->lock = NULL;
}
mtx_destroy(&sc->lock);
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);

54
sys/dev/sound/pci/cmi.c
View file

@ -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)
snd_mtxfree(sc->lock);
mtx_destroy(&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;
}

57
sys/dev/sound/pci/emu10k1.c
View file

@ -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 @@ bad:
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;

47
sys/dev/sound/pci/emu10kx-pcm.c
View file

@ -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)
snd_mtxfree(sc->lock);
mtx_destroy(&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)
snd_mtxfree(sc->lock);
mtx_destroy(&sc->lock);
free(sc, M_DEVBUF);
return (0);

68
sys/dev/sound/pci/envy24.c
View file

@ -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 @@ bad:
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)
snd_mtxfree(sc->lock);
mtx_destroy(&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;
}

69
sys/dev/sound/pci/envy24ht.c
View file

@ -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),
"snd_envy24ht softc");
mtx_init(&sc->lock, device_get_nameunit(dev), "snd_eny24ht softc",
MTX_DEF);
sc->dev = dev;
/* initialize PCI interface */
@ -2524,8 +2524,7 @@ bad:
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)
snd_mtxfree(sc->lock);
mtx_destroy(&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;
}

16
sys/dev/sound/pci/es137x.c
View file

@ -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_UNLOCK(sc) snd_mtxunlock((sc)->lock)
#define ES_LOCK_ASSERT(sc) snd_mtxassert((sc)->lock)
#define ES_LOCK(sc) mtx_lock(&(sc)->lock)
#define ES_UNLOCK(sc) mtx_unlock(&(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 @@ bad:
ac97_destroy(codec);
if (es->reg)
bus_release_resource(dev, es->regtype, es->regid, es->reg);
if (es->lock)
snd_mtxfree(es->lock);
mtx_destroy(&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);

6
sys/dev/sound/pci/hda/hdaa.c
View file

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

15
sys/dev/sound/pci/hda/hdac.c
View file

@ -51,9 +51,9 @@
#define HDA_DRV_TEST_REV "20120126_0002"
#define hdac_lock(sc) snd_mtxlock((sc)->lock)
#define hdac_unlock(sc) snd_mtxunlock((sc)->lock)
#define hdac_lockassert(sc) snd_mtxassert((sc)->lock)
#define hdac_lock(sc) mtx_lock(&(sc)->lock)
#define hdac_unlock(sc) mtx_unlock(&(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_fail:
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

2
sys/dev/sound/pci/hda/hdac_private.h
View file

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

6
sys/dev/sound/pci/hda/hdacc.c
View file

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

28
sys/dev/sound/pci/hdsp-pcm.c
View file

@ -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);

35
sys/dev/sound/pci/hdsp.c
View file

@ -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),
"snd_hdsp softc");
mtx_init(&sc->lock, device_get_nameunit(dev), "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)
snd_mtxfree(sc->lock);
mtx_destroy(&sc->lock);
return (0);
}

2
sys/dev/sound/pci/hdsp.h
View file

@ -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;

28
sys/dev/sound/pci/hdspe-pcm.c
View file

@ -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);

35
sys/dev/sound/pci/hdspe.c
View file

@ -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),
"snd_hdspe softc");
mtx_init(&sc->lock, device_get_nameunit(dev), "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)
snd_mtxfree(sc->lock);
mtx_destroy(&sc->lock);
return (0);
}

2
sys/dev/sound/pci/hdspe.h
View file

@ -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;

16
sys/dev/sound/pci/ich.c
View file

@ -77,9 +77,9 @@
#define AMD_768 0x7445
#define AMD_8111 0x746d
#define ICH_LOCK(sc) snd_mtxlock((sc)->ich_lock)
#define ICH_UNLOCK(sc) snd_mtxunlock((sc)->ich_lock)
#define ICH_LOCK_ASSERT(sc) snd_mtxassert((sc)->ich_lock)
#define ICH_LOCK(sc) mtx_lock(&(sc)->ich_lock)
#define ICH_UNLOCK(sc) mtx_unlock(&(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 @@ bad:
bus_dma_tag_destroy(sc->chan_dmat);
if (sc->dmat)
bus_dma_tag_destroy(sc->dmat);
if (sc->ich_lock)
snd_mtxfree(sc->ich_lock);
mtx_destroy(&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);
}

17
sys/dev/sound/pci/maestro3.c
View file

@ -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_UNLOCK(_sc) snd_mtxunlock((_sc)->sc_lock)
#define M3_LOCK_ASSERT(_sc) snd_mtxassert((_sc)->sc_lock)
#define M3_LOCK(_sc) mtx_lock(&(_sc)->sc_lock)
#define M3_UNLOCK(_sc) mtx_unlock(&(_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),
"snd_maestro3 softc");
mtx_init(&sc->sc_lock, device_get_nameunit(dev), "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)
snd_mtxfree(sc->sc_lock);
mtx_destroy(&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;
}

18
sys/dev/sound/pci/solo.c
View file

@ -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_unlock(_ess) snd_mtxunlock((_ess)->lock)
#define ess_lock_assert(_ess) snd_mtxassert((_ess)->lock)
#define ess_lock(_ess) mtx_lock(&(_ess)->lock)
#define ess_unlock(_ess) mtx_unlock(&(_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) {
snd_mtxfree(sc->lock);
sc->lock = NULL;
}
mtx_destroy(&sc->lock);
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

34
sys/dev/sound/pci/spicds.c
View file

@ -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);

29
sys/dev/sound/pci/t4dwave.c
View file

@ -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 @@ bad:
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;

101
sys/dev/sound/pci/via8233.c
View file

@ -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),
"snd_via8233 softc");
mtx_init(&via->lock, device_get_nameunit(dev), "snd_via8233 softc",
MTX_DEF);
via->dev = dev;
callout_init(&via->poll_timer, 1);
@ -1384,8 +1384,7 @@ bad:
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);
@ -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);
}

36
sys/dev/sound/pci/via82c686.c
View file

@ -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),
"snd_via82c686 softc");
mtx_init(&via->lock, device_get_nameunit(dev), "snd_via82c686 softc",
MTX_DEF);
pci_enable_busmaster(dev);
@ -600,7 +600,7 @@ bad:
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;
}

52
sys/dev/sound/pcm/ac97.c
View file

@ -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),

16
sys/dev/sound/pcm/channel.c
View file

@ -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) {

14
sys/dev/sound/pcm/channel.h
View file

@ -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_LOCK(c) mtx_lock((c)->lock)
#define CHN_UNLOCK(c) mtx_unlock((c)->lock)
#define CHN_TRYLOCK(c) mtx_trylock((c)->lock)
#define CHN_LOCKASSERT(c) mtx_assert((c)->lock, MA_OWNED)
#define CHN_UNLOCKASSERT(c) mtx_assert((c)->lock, MA_NOTOWNED)
#define CHN_LOCKOWNED(c) mtx_owned(&(c)->lock)
#define CHN_LOCK(c) mtx_lock(&(c)->lock)
#define CHN_UNLOCK(c) mtx_unlock(&(c)->lock)
#define CHN_TRYLOCK(c) mtx_trylock(&(c)->lock)
#define CHN_LOCKASSERT(c) mtx_assert(&(c)->lock, MA_OWNED)
#define CHN_UNLOCKASSERT(c) mtx_assert(&(c)->lock, MA_NOTOWNED)
#define CHN_BROADCAST(x) cv_broadcastpri(x, PRIBIO)

4
sys/dev/sound/pcm/dsp.c
View file

@ -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);

105
sys/dev/sound/pcm/mixer.c
View file

@ -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) ?
"primary pcm mixer" : "secondary pcm mixer");
mtx_init(&m->lock, m->name, (type == MIXER_TYPE_PRIMARY) ?
"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);
snd_mtxfree(m->lock);
mtx_lock(&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 (&Giant);
}
return (m->lock);
return (&m->lock);
}

33
sys/dev/sound/pcm/sound.c
View file

@ -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);

24
sys/dev/sound/pcm/sound.h
View file

@ -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_LOCK(d) mtx_lock((d)->lock)
#define PCM_UNLOCK(d) mtx_unlock((d)->lock)
#define PCM_TRYLOCK(d) mtx_trylock((d)->lock)
#define PCM_LOCKASSERT(d) mtx_assert((d)->lock, MA_OWNED)
#define PCM_UNLOCKASSERT(d) mtx_assert((d)->lock, MA_NOTOWNED)
#define PCM_LOCKOWNED(d) mtx_owned(&(d)->lock)
#define PCM_LOCK(d) mtx_lock(&(d)->lock)
#define PCM_UNLOCK(d) mtx_unlock(&(d)->lock)
#define PCM_TRYLOCK(d) mtx_trylock(&(d)->lock)
#define PCM_LOCKASSERT(d) mtx_assert(&(d)->lock, MA_OWNED)
#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 { \

2
sys/dev/sound/usb/uaudio.c
View file

@ -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 */