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: Get rid of useless sndbuf getters and setters

Browse source 
No functional change intended.

Sponsored by:	The FreeBSD Foundation
MFC after:	1 week
Differential Revision:	https://reviews.freebsd.org/D53528
This commit is contained in:
Christos Margiolis 2025-11-11 13:05:34 +01:00
parent ad28c6a13a
commit 78c5026ae1
39 changed files with 272 additions and 433 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -680,7 +680,7 @@ a10codec_dmaintr(void *priv)
struct a10codec_chinfo *ch = priv;
unsigned bufsize;
bufsize = sndbuf_getsize(ch->buffer);
bufsize = ch->buffer->bufsize;
ch->pos += ch->blocksize;
if (ch->pos >= bufsize)

8
sys/arm/allwinner/aw_i2s.c
View file

@ -530,10 +530,10 @@ aw_i2s_dai_intr(device_t dev, struct snd_dbuf *play_buf, struct snd_dbuf *rec_bu
val = I2S_READ(sc, DA_FSTA);
empty = DA_FSTA_TXE_CNT(val);
count = sndbuf_getready(play_buf);
size = sndbuf_getsize(play_buf);
size = play_buf->bufsize;
readyptr = sndbuf_getreadyptr(play_buf);
samples = (uint8_t*)sndbuf_getbuf(play_buf);
samples = play_buf->buf;
written = 0;
if (empty > count / 2)
empty = count / 2;
@ -556,9 +556,9 @@ aw_i2s_dai_intr(device_t dev, struct snd_dbuf *play_buf, struct snd_dbuf *rec_bu
available = DA_FSTA_RXA_CNT(val);
count = sndbuf_getfree(rec_buf);
size = sndbuf_getsize(rec_buf);
size = rec_buf->bufsize;
freeptr = sndbuf_getfreeptr(rec_buf);
samples = (uint8_t*)sndbuf_getbuf(rec_buf);
samples = rec_buf->buf;
recorded = 0;
if (available > count / 2)
available = count / 2;

9
sys/arm/broadcom/bcm2835/bcm2835_audio.c
View file

@ -575,7 +575,7 @@ bcm2835_audio_worker(void *data)
continue;
count = sndbuf_getready(ch->buffer);
size = sndbuf_getsize(ch->buffer);
size = ch->buffer->bufsize;
readyptr = sndbuf_getreadyptr(ch->buffer);
BCM2835_AUDIO_LOCK(sc);
@ -588,11 +588,12 @@ bcm2835_audio_worker(void *data)
if (count < VCHIQ_AUDIO_PACKET_SIZE)
continue;
buf = (uint8_t*)sndbuf_getbuf(ch->buffer) + readyptr;
buf = ch->buffer->buf + readyptr;
bcm2835_audio_write_samples(ch, buf, count);
BCM2835_AUDIO_LOCK(sc);
ch->unsubmittedptr = (ch->unsubmittedptr + count) % sndbuf_getsize(ch->buffer);
ch->unsubmittedptr = (ch->unsubmittedptr + count) %
ch->buffer->bufsize;
ch->available_space -= count;
ch->submitted_samples += count;
KASSERT(ch->available_space >= 0, ("ch->available_space == %d\n", ch->available_space));
@ -662,7 +663,7 @@ bcmchan_free(kobj_t obj, void *data)
struct bcm2835_audio_chinfo *ch = data;
void *buffer;
buffer = sndbuf_getbuf(ch->buffer);
buffer = ch->buffer->buf;
if (buffer)
free(buffer, M_DEVBUF);

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

@ -398,7 +398,7 @@ ssichan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
setup_dma(scp);
return (sndbuf_getblksz(ch->buffer));
return (ch->buffer->blksz);
}
uint32_t
@ -415,7 +415,7 @@ ssi_dma_intr(void *arg, int chn)
sc = scp->sc;
conf = sc->conf;
bufsize = sndbuf_getsize(ch->buffer);
bufsize = ch->buffer->bufsize;
sc->pos += conf->period;
if (sc->pos >= bufsize)
@ -487,8 +487,8 @@ setup_dma(struct sc_pcminfo *scp)
conf->saddr = sc->buf_base_phys;
conf->daddr = rman_get_start(sc->res[0]) + SSI_STX0;
conf->event = sc->sdma_ev_tx; /* SDMA TX event */
conf->period = sndbuf_getblksz(ch->buffer);
conf->num_bd = sndbuf_getblkcnt(ch->buffer);
conf->period = ch->buffer->blksz;
conf->num_bd = ch->buffer->blkcnt;
/*
* Word Length
@ -497,7 +497,7 @@ setup_dma(struct sc_pcminfo *scp)
* SSI supports 24 at max.
*/
fmt = sndbuf_getfmt(ch->buffer);
fmt = ch->buffer->fmt;
if (fmt & AFMT_16BIT) {
conf->word_length = 16;

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

@ -369,7 +369,7 @@ saichan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
sndbuf_resize(ch->buffer, sc->dma_size / blocksize, blocksize);
sc->period = sndbuf_getblksz(ch->buffer);
sc->period = ch->buffer->blksz;
return (sc->period);
}

8
sys/arm64/rockchip/rk_i2s.c
View file

@ -403,10 +403,10 @@ rk_i2s_dai_intr(device_t dev, struct snd_dbuf *play_buf, struct snd_dbuf *rec_bu
count = sndbuf_getready(play_buf);
if (count > FIFO_SIZE - 1)
count = FIFO_SIZE - 1;
size = sndbuf_getsize(play_buf);
size = play_buf->bufsize;
readyptr = sndbuf_getreadyptr(play_buf);
samples = (uint8_t*)sndbuf_getbuf(play_buf);
samples = play_buf->buf;
written = 0;
for (; level < count; level++) {
val = (samples[readyptr++ % size] << 0);
@ -426,9 +426,9 @@ rk_i2s_dai_intr(device_t dev, struct snd_dbuf *play_buf, struct snd_dbuf *rec_bu
uint8_t *samples;
uint32_t count, size, freeptr, recorded;
count = sndbuf_getfree(rec_buf);
size = sndbuf_getsize(rec_buf);
size = rec_buf->bufsize;
freeptr = sndbuf_getfreeptr(rec_buf);
samples = (uint8_t*)sndbuf_getbuf(rec_buf);
samples = rec_buf->buf;
recorded = 0;
if (level > count / 4)
level = count / 4;

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

@ -105,8 +105,8 @@ dummy_chan_io(void *arg)
if (!ch->run)
continue;
if (ch->dir == PCMDIR_PLAY) {
ch->ptr += sndbuf_getblksz(ch->buf);
ch->ptr %= sndbuf_getsize(ch->buf);
ch->ptr += ch->buf->blksz;
ch->ptr %= ch->buf->bufsize;
} else
sndbuf_fillsilence(ch->buf);
snd_mtxunlock(sc->lock);
@ -123,7 +123,7 @@ dummy_chan_free(kobj_t obj, void *data)
struct dummy_chan *ch =data;
uint8_t *buf;
buf = sndbuf_getbuf(ch->buf);
buf = ch->buf->buf;
if (buf != NULL)
free(buf, M_DEVBUF);
@ -190,7 +190,7 @@ dummy_chan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
{
struct dummy_chan *ch = data;
return (sndbuf_getblksz(ch->buf));
return (ch->buf->blksz);
}
static int

2
sys/dev/sound/fdt/audio_soc.c
View file

@ -249,7 +249,7 @@ audio_soc_chan_free(kobj_t obj, void *data)
ausoc_chan = (struct audio_soc_channel *)data;
buffer = sndbuf_getbuf(ausoc_chan->buf);
buffer = ausoc_chan->buf->buf;
if (buffer)
free(buffer, M_DEVBUF);

4
sys/dev/sound/macio/aoa.c
View file

@ -73,8 +73,8 @@ aoa_dma_set_program(struct aoa_dma *dma)
u_int32_t addr;
int i;
addr = (u_int32_t) sndbuf_getbufaddr(dma->buf);
KASSERT(dma->bufsz == sndbuf_getsize(dma->buf), ("bad size"));
addr = (u_int32_t)dma->buf->buf_addr;
KASSERT(dma->bufsz == dma->buf->bufsize, ("bad size"));
dma->slots = dma->bufsz / dma->blksz;

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

@ -281,7 +281,7 @@ alschan_getptr(kobj_t obj, void *data)
snd_mtxlock(sc->lock);
pos = als_gcr_rd(ch->parent, ch->gcr_fifo_status) & 0xffff;
snd_mtxunlock(sc->lock);
sz = sndbuf_getsize(ch->buffer);
sz = ch->buffer->bufsize;
return (2 * sz - pos - 1) % sz;
}
@ -348,8 +348,8 @@ als_playback_start(struct sc_chinfo *ch)
struct sc_info *sc = ch->parent;
u_int32_t buf, bufsz, count, dma_prog;
buf = sndbuf_getbufaddr(ch->buffer);
bufsz = sndbuf_getsize(ch->buffer);
buf = ch->buffer->buf_addr;
bufsz = ch->buffer->bufsize;
count = bufsz / 2;
if (ch->format & AFMT_16BIT)
count /= 2;
@ -451,8 +451,8 @@ als_capture_start(struct sc_chinfo *ch)
struct sc_info *sc = ch->parent;
u_int32_t buf, bufsz, count, dma_prog;
buf = sndbuf_getbufaddr(ch->buffer);
bufsz = sndbuf_getsize(ch->buffer);
buf = ch->buffer->buf_addr;
bufsz = ch->buffer->bufsize;
count = bufsz / 2;
if (ch->format & AFMT_16BIT)
count /= 2;

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

@ -535,8 +535,8 @@ atiixp_chan_setfragments(kobj_t obj, void *data,
blksz &= ATI_IXP_BLK_ALIGN;
if (blksz > (sndbuf_getmaxsize(ch->buffer) / ATI_IXP_DMA_CHSEGS_MIN))
blksz = sndbuf_getmaxsize(ch->buffer) / ATI_IXP_DMA_CHSEGS_MIN;
if (blksz > (ch->buffer->maxsize / ATI_IXP_DMA_CHSEGS_MIN))
blksz = ch->buffer->maxsize / ATI_IXP_DMA_CHSEGS_MIN;
if (blksz < ATI_IXP_BLK_MIN)
blksz = ATI_IXP_BLK_MIN;
if (blkcnt > ATI_IXP_DMA_CHSEGS_MAX)
@ -544,7 +544,7 @@ atiixp_chan_setfragments(kobj_t obj, void *data,
if (blkcnt < ATI_IXP_DMA_CHSEGS_MIN)
blkcnt = ATI_IXP_DMA_CHSEGS_MIN;
while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
while ((blksz * blkcnt) > ch->buffer->maxsize) {
if ((blkcnt >> 1) >= ATI_IXP_DMA_CHSEGS_MIN)
blkcnt >>= 1;
else if ((blksz >> 1) >= ATI_IXP_BLK_MIN)
@ -553,14 +553,14 @@ atiixp_chan_setfragments(kobj_t obj, void *data,
break;
}
if ((sndbuf_getblksz(ch->buffer) != blksz ||
sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
if ((ch->buffer->blksz != blksz ||
ch->buffer->blkcnt != blkcnt) &&
sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
device_printf(sc->dev, "%s: failed blksz=%u blkcnt=%u\n",
__func__, blksz, blkcnt);
ch->blksz = sndbuf_getblksz(ch->buffer);
ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
ch->blksz = ch->buffer->blksz;
ch->blkcnt = ch->buffer->blkcnt;
return (0);
}
@ -583,7 +583,7 @@ atiixp_buildsgdt(struct atiixp_chinfo *ch)
uint32_t addr, blksz, blkcnt;
int i;
addr = sndbuf_getbufaddr(ch->buffer);
addr = ch->buffer->buf_addr;
if (sc->polling != 0) {
blksz = ch->blksz * ch->blkcnt;
@ -610,7 +610,7 @@ atiixp_dmapos(struct atiixp_chinfo *ch)
volatile uint32_t ptr;
reg = ch->dt_cur_bit;
addr = sndbuf_getbufaddr(ch->buffer);
addr = ch->buffer->buf_addr;
sz = ch->blkcnt * ch->blksz;
retry = ATI_IXP_DMA_RETRY_MAX;
@ -739,8 +739,7 @@ atiixp_chan_trigger(kobj_t obj, void *data, int go)
ch->ptr = 0;
ch->prevptr = 0;
pollticks = ((uint64_t)hz * ch->blksz) /
((uint64_t)sndbuf_getalign(ch->buffer) *
sndbuf_getspd(ch->buffer));
((uint64_t)ch->buffer->align * ch->buffer->spd);
pollticks >>= 2;
if (pollticks > hz)
pollticks = hz;
@ -781,8 +780,8 @@ atiixp_chan_trigger(kobj_t obj, void *data, int go)
else
ch = &sc->rch;
pollticks = ((uint64_t)hz * ch->blksz) /
((uint64_t)sndbuf_getalign(ch->buffer) *
sndbuf_getspd(ch->buffer));
((uint64_t)ch->buffer->align *
ch->buffer->spd);
pollticks >>= 2;
if (pollticks > hz)
pollticks = hz;

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

@ -255,10 +255,10 @@ cmi_dma_prog(struct sc_info *sc, struct sc_chinfo *ch, u_int32_t base)
{
u_int32_t s, i, sz;
ch->phys_buf = sndbuf_getbufaddr(ch->buffer);
ch->phys_buf = ch->buffer->buf_addr;
cmi_wr(sc, base, ch->phys_buf, 4);
sz = (u_int32_t)sndbuf_getsize(ch->buffer);
sz = (u_int32_t)ch->buffer->bufsize;
s = sz / ch->bps - 1;
cmi_wr(sc, base + 4, s, 2);
@ -525,7 +525,7 @@ cmichan_getptr(kobj_t obj, void *data)
}
snd_mtxunlock(sc->lock);
sz = sndbuf_getsize(ch->buffer);
sz = ch->buffer->bufsize;
bufptr = (physptr - ch->phys_buf + sz - ch->bps) % sz;
return bufptr;

8
sys/dev/sound/pci/cs4281.c
View file

@ -328,7 +328,7 @@ cs4281chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channe
ch->fmt = SND_FORMAT(AFMT_U8, 1, 0);
ch->spd = DSP_DEFAULT_SPEED;
ch->bps = 1;
ch->blksz = sndbuf_getsize(ch->buffer);
ch->blksz = ch->buffer->bufsize;
ch->dma_chan = (dir == PCMDIR_PLAY) ? CS4281_DMA_PLAY : CS4281_DMA_REC;
ch->dma_setup = 0;
@ -412,7 +412,7 @@ cs4281chan_getptr(kobj_t obj, void *data)
u_int32_t dba, dca, ptr;
int sz;
sz = sndbuf_getsize(ch->buffer);
sz = ch->buffer->bufsize;
dba = cs4281_rd(sc, CS4281PCI_DBA(ch->dma_chan));
dca = cs4281_rd(sc, CS4281PCI_DCA(ch->dma_chan));
ptr = (dca - dba + sz) % sz;
@ -493,9 +493,9 @@ adcdac_prog(struct sc_chinfo *ch)
if (!ch->dma_setup) {
go = adcdac_go(ch, 0);
cs4281_wr(sc, CS4281PCI_DBA(ch->dma_chan),
sndbuf_getbufaddr(ch->buffer));
ch->buffer->buf_addr);
cs4281_wr(sc, CS4281PCI_DBC(ch->dma_chan),
sndbuf_getsize(ch->buffer) / ch->bps - 1);
ch->buffer->bufsize / ch->bps - 1);
ch->dma_setup = 1;
adcdac_go(ch, go);
}

8
sys/dev/sound/pci/csapcm.c
View file

@ -483,7 +483,7 @@ csa_setupchan(struct csa_chinfo *ch)
if (ch->dir == PCMDIR_PLAY) {
/* direction */
csa_writemem(resp, BA1_PBA, sndbuf_getbufaddr(ch->buffer));
csa_writemem(resp, BA1_PBA, ch->buffer->buf_addr);
/* format */
csa->pfie = csa_readmem(resp, BA1_PFIE) & ~0x0000f03f;
@ -512,7 +512,7 @@ csa_setupchan(struct csa_chinfo *ch)
csa_setplaysamplerate(resp, ch->spd);
} else if (ch->dir == PCMDIR_REC) {
/* direction */
csa_writemem(resp, BA1_CBA, sndbuf_getbufaddr(ch->buffer));
csa_writemem(resp, BA1_CBA, ch->buffer->buf_addr);
/* format */
csa_writemem(resp, BA1_CIE, (csa_readmem(resp, BA1_CIE) & ~0x0000003f) | 0x00000001);
@ -602,11 +602,11 @@ csachan_getptr(kobj_t obj, void *data)
resp = &csa->res;
if (ch->dir == PCMDIR_PLAY) {
ptr = csa_readmem(resp, BA1_PBA) - sndbuf_getbufaddr(ch->buffer);
ptr = csa_readmem(resp, BA1_PBA) - ch->buffer->buf_addr;
if ((ch->fmt & AFMT_U8) != 0 || (ch->fmt & AFMT_S8) != 0)
ptr >>= 1;
} else {
ptr = csa_readmem(resp, BA1_CBA) - sndbuf_getbufaddr(ch->buffer);
ptr = csa_readmem(resp, BA1_CBA) - ch->buffer->buf_addr;
if ((ch->fmt & AFMT_U8) != 0 || (ch->fmt & AFMT_S8) != 0)
ptr >>= 1;
}

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

@ -413,7 +413,7 @@ emu_settimer(struct sc_info *sc)
for (i = 0; i < sc->nchans; i++) {
pch = &sc->pch[i];
if (pch->buffer) {
tmp = (pch->spd * sndbuf_getalign(pch->buffer))
tmp = (pch->spd * pch->buffer->align)
/ pch->blksz;
if (tmp > rate)
rate = tmp;
@ -423,7 +423,7 @@ emu_settimer(struct sc_info *sc)
for (i = 0; i < 3; i++) {
rch = &sc->rch[i];
if (rch->buffer) {
tmp = (rch->spd * sndbuf_getalign(rch->buffer))
tmp = (rch->spd * rch->buffer->align)
/ rch->blksz;
if (tmp > rate)
rate = tmp;
@ -838,7 +838,7 @@ emupchan_free(kobj_t obj, void *data)
int r;
snd_mtxlock(sc->lock);
r = emu_memfree(sc, sndbuf_getbuf(ch->buffer));
r = emu_memfree(sc, ch->buffer->buf);
snd_mtxunlock(sc->lock);
return r;
@ -985,7 +985,7 @@ emurchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
return NULL;
else {
snd_mtxlock(sc->lock);
emu_wrptr(sc, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
emu_wrptr(sc, 0, ch->basereg, ch->buffer->buf_addr);
emu_wrptr(sc, 0, ch->sizereg, 0); /* off */
snd_mtxunlock(sc->lock);
return ch;

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

@ -773,7 +773,7 @@ emupchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
blocksize = ch->pcm->bufsz;
snd_mtxlock(sc->lock);
ch->blksz = blocksize;
emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
emu_timer_set(sc->card, ch->timer, ch->blksz / ch->buffer->align);
snd_mtxunlock(sc->lock);
return (ch->blksz);
}
@ -795,7 +795,8 @@ emupchan_trigger(kobj_t obj __unused, void *c_devinfo, int go)
else
emu_vroute(sc->card, &(sc->rt_mono), ch->master);
emu_vwrite(sc->card, ch->master);
emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
emu_timer_set(sc->card, ch->timer, ch->blksz /
ch->buffer->align);
emu_timer_enable(sc->card, ch->timer, 1);
}
/* PCM interrupt handler will handle PCMTRIG_STOP event */
@ -878,7 +879,7 @@ emurchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct pcm
return (NULL);
else {
ch->timer = emu_timer_create(sc->card);
emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
emu_wrptr(sc->card, 0, ch->basereg, ch->buffer->buf_addr);
emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
return (ch);
}
@ -930,7 +931,8 @@ emurchan_setblocksize(kobj_t obj __unused, void *c_devinfo, uint32_t blocksize)
* (and use) timer interrupts. Otherwise channel will be marked dead.
*/
if (ch->blksz < (ch->pcm->bufsz / 2)) {
emu_timer_set(sc->card, ch->timer, ch->blksz / sndbuf_getalign(ch->buffer));
emu_timer_set(sc->card, ch->timer, ch->blksz /
ch->buffer->align);
emu_timer_enable(sc->card, ch->timer, 1);
} else {
emu_timer_enable(sc->card, ch->timer, 0);
@ -1059,7 +1061,7 @@ emufxrchan_init(kobj_t obj __unused, void *devinfo, struct snd_dbuf *b, struct p
if (sndbuf_alloc(ch->buffer, emu_gettag(sc->card), 0, sc->bufsz) != 0)
return (NULL);
else {
emu_wrptr(sc->card, 0, ch->basereg, sndbuf_getbufaddr(ch->buffer));
emu_wrptr(sc->card, 0, ch->basereg, ch->buffer->buf_addr);
emu_wrptr(sc->card, 0, ch->sizereg, 0); /* off */
return (ch);
}

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

@ -508,21 +508,21 @@ eschan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
es_wr(es, ES1370_REG_MEMPAGE,
ES1370_REG_DAC1_FRAMEADR >> 8, 1);
es_wr(es, ES1370_REG_DAC1_FRAMEADR & 0xff,
sndbuf_getbufaddr(ch->buffer), 4);
ch->buffer->buf_addr, 4);
es_wr(es, ES1370_REG_DAC1_FRAMECNT & 0xff,
(ch->bufsz >> 2) - 1, 4);
} else {
es_wr(es, ES1370_REG_MEMPAGE,
ES1370_REG_DAC2_FRAMEADR >> 8, 1);
es_wr(es, ES1370_REG_DAC2_FRAMEADR & 0xff,
sndbuf_getbufaddr(ch->buffer), 4);
ch->buffer->buf_addr, 4);
es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff,
(ch->bufsz >> 2) - 1, 4);
}
} else {
es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMEADR >> 8, 1);
es_wr(es, ES1370_REG_ADC_FRAMEADR & 0xff,
sndbuf_getbufaddr(ch->buffer), 4);
ch->buffer->buf_addr, 4);
es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff,
(ch->bufsz >> 2) - 1, 4);
}
@ -637,8 +637,8 @@ eschan_setfragments(kobj_t obj, void *data, uint32_t blksz, uint32_t blkcnt)
blksz &= ES_BLK_ALIGN;
if (blksz > (sndbuf_getmaxsize(ch->buffer) / ES_DMA_SEGS_MIN))
blksz = sndbuf_getmaxsize(ch->buffer) / ES_DMA_SEGS_MIN;
if (blksz > (ch->buffer->maxsize / ES_DMA_SEGS_MIN))
blksz = ch->buffer->maxsize / ES_DMA_SEGS_MIN;
if (blksz < ES_BLK_MIN)
blksz = ES_BLK_MIN;
if (blkcnt > ES_DMA_SEGS_MAX)
@ -646,7 +646,7 @@ eschan_setfragments(kobj_t obj, void *data, uint32_t blksz, uint32_t blkcnt)
if (blkcnt < ES_DMA_SEGS_MIN)
blkcnt = ES_DMA_SEGS_MIN;
while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
while ((blksz * blkcnt) > ch->buffer->maxsize) {
if ((blkcnt >> 1) >= ES_DMA_SEGS_MIN)
blkcnt >>= 1;
else if ((blksz >> 1) >= ES_BLK_MIN)
@ -655,15 +655,15 @@ eschan_setfragments(kobj_t obj, void *data, uint32_t blksz, uint32_t blkcnt)
break;
}
if ((sndbuf_getblksz(ch->buffer) != blksz ||
sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
if ((ch->buffer->blksz != blksz ||
ch->buffer->blkcnt != blkcnt) &&
sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
device_printf(es->dev, "%s: failed blksz=%u blkcnt=%u\n",
__func__, blksz, blkcnt);
ch->bufsz = sndbuf_getsize(ch->buffer);
ch->blksz = sndbuf_getblksz(ch->buffer);
ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
ch->bufsz = ch->buffer->bufsize;
ch->blksz = ch->buffer->blksz;
ch->blkcnt = ch->buffer->blkcnt;
return (0);
}
@ -762,7 +762,7 @@ eschan_trigger(kobj_t obj, void *data, int go)
return 0;
ES_LOCK(es);
cnt = (ch->blksz / sndbuf_getalign(ch->buffer)) - 1;
cnt = (ch->blksz / ch->buffer->align) - 1;
if (ch->fmt & AFMT_16BIT)
b |= 0x02;
if (AFMT_CHANNEL(ch->fmt) > 1)

2
sys/dev/sound/pci/fm801.c
View file

@ -440,7 +440,7 @@ fm801ch_trigger(kobj_t obj, void *data, int go)
{
struct fm801_chinfo *ch = data;
struct fm801_info *fm801 = ch->parent;
u_int32_t baseaddr = sndbuf_getbufaddr(ch->buffer);
u_int32_t baseaddr = ch->buffer->buf_addr;
u_int32_t k1;
DPRINT("fm801ch_trigger go %d , ", go);

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

@ -2081,10 +2081,10 @@ hdaa_channel_setfragments(kobj_t obj, void *data,
{
struct hdaa_chan *ch = data;
blksz -= blksz % lcm(HDA_DMA_ALIGNMENT, sndbuf_getalign(ch->b));
blksz -= blksz % lcm(HDA_DMA_ALIGNMENT, ch->b->align);
if (blksz > (sndbuf_getmaxsize(ch->b) / HDA_BDL_MIN))
blksz = sndbuf_getmaxsize(ch->b) / HDA_BDL_MIN;
if (blksz > (ch->b->maxsize / HDA_BDL_MIN))
blksz = ch->b->maxsize / HDA_BDL_MIN;
if (blksz < HDA_BLK_MIN)
blksz = HDA_BLK_MIN;
if (blkcnt > HDA_BDL_MAX)
@ -2092,7 +2092,7 @@ hdaa_channel_setfragments(kobj_t obj, void *data,
if (blkcnt < HDA_BDL_MIN)
blkcnt = HDA_BDL_MIN;
while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->b)) {
while ((blksz * blkcnt) > ch->b->maxsize) {
if ((blkcnt >> 1) >= HDA_BDL_MIN)
blkcnt >>= 1;
else if ((blksz >> 1) >= HDA_BLK_MIN)
@ -2101,14 +2101,14 @@ hdaa_channel_setfragments(kobj_t obj, void *data,
break;
}
if ((sndbuf_getblksz(ch->b) != blksz ||
sndbuf_getblkcnt(ch->b) != blkcnt) &&
if ((ch->b->blksz != blksz ||
ch->b->blkcnt != blkcnt) &&
sndbuf_resize(ch->b, blkcnt, blksz) != 0)
device_printf(ch->devinfo->dev, "%s: failed blksz=%u blkcnt=%u\n",
__func__, blksz, blkcnt);
ch->blksz = sndbuf_getblksz(ch->b);
ch->blkcnt = sndbuf_getblkcnt(ch->b);
ch->blksz = ch->b->blksz;
ch->blkcnt = ch->b->blkcnt;
return (0);
}
@ -2169,7 +2169,7 @@ hdaa_channel_start(struct hdaa_chan *ch)
ch->dir == PCMDIR_PLAY ? 1 : 0, ch->sid);
HDAC_STREAM_START(device_get_parent(devinfo->dev), devinfo->dev,
ch->dir == PCMDIR_PLAY ? 1 : 0, ch->sid,
sndbuf_getbufaddr(ch->b), ch->blksz, ch->blkcnt);
ch->b->buf_addr, ch->blksz, ch->blkcnt);
ch->flags |= HDAA_CHN_RUNNING;
return (0);
}

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

@ -971,7 +971,7 @@ hdspchan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
hdsp_write_4(sc, HDSP_FREQ_REG, hdsp_freq_reg_value(sc->speed));
end:
return (sndbuf_getblksz(ch->buffer));
return (ch->buffer->blksz);
}
static uint32_t hdsp_bkp_fmt[] = {

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

@ -962,7 +962,7 @@ hdspechan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
(sc->period * 4));
end:
return (sndbuf_getblksz(ch->buffer));
return (ch->buffer->blksz);
}
static uint32_t hdspe_bkp_fmt[] = {

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

@ -301,15 +301,15 @@ ich_filldtbl(struct sc_chinfo *ch)
uint32_t base;
int i;
base = sndbuf_getbufaddr(ch->buffer);
if ((ch->blksz * ch->blkcnt) > sndbuf_getmaxsize(ch->buffer))
ch->blksz = sndbuf_getmaxsize(ch->buffer) / ch->blkcnt;
if ((sndbuf_getblksz(ch->buffer) != ch->blksz ||
sndbuf_getblkcnt(ch->buffer) != ch->blkcnt) &&
base = ch->buffer->buf_addr;
if ((ch->blksz * ch->blkcnt) > ch->buffer->maxsize)
ch->blksz = ch->buffer->maxsize / ch->blkcnt;
if ((ch->buffer->blksz != ch->blksz ||
ch->buffer->blkcnt != ch->blkcnt) &&
sndbuf_resize(ch->buffer, ch->blkcnt, ch->blksz) != 0)
device_printf(sc->dev, "%s: failed blksz=%u blkcnt=%u\n",
__func__, ch->blksz, ch->blkcnt);
ch->blksz = sndbuf_getblksz(ch->buffer);
ch->blksz = ch->buffer->blksz;
for (i = 0; i < ICH_DTBL_LENGTH; i++) {
ch->dtbl[i].buffer = base + (ch->blksz * (i % ch->blkcnt));
@ -491,7 +491,7 @@ ichchan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
);
if (sc->flags & ICH_HIGH_LATENCY)
blocksize = sndbuf_getmaxsize(ch->buffer) / ch->blkcnt;
blocksize = ch->buffer->maxsize / ch->blkcnt;
if (blocksize < ICH_MIN_BLKSZ)
blocksize = ICH_MIN_BLKSZ;
@ -734,7 +734,7 @@ ich_calibrate(void *arg)
ch->blkcnt = 2;
sc->flags |= ICH_CALIBRATE_DONE;
ICH_UNLOCK(sc);
ichchan_setblocksize(0, ch, sndbuf_getmaxsize(ch->buffer) >> 1);
ichchan_setblocksize(0, ch, ch->buffer->maxsize >> 1);
ICH_LOCK(sc);
sc->flags &= ~ICH_CALIBRATE_DONE;

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

@ -444,10 +444,10 @@ m3_pchan_init(kobj_t kobj, void *devinfo, struct snd_dbuf *b, struct pcm_channel
return (NULL);
}
M3_LOCK(sc);
ch->bufsize = sndbuf_getsize(ch->buffer);
ch->bufsize = ch->buffer->bufsize;
/* host dma buffer pointers */
bus_addr = sndbuf_getbufaddr(ch->buffer);
bus_addr = ch->buffer->buf_addr;
if (bus_addr & 3) {
device_printf(sc->dev, "m3_pchan_init unaligned bus_addr\n");
bus_addr = (bus_addr + 4) & ~3;
@ -595,7 +595,7 @@ m3_pchan_setblocksize(kobj_t kobj, void *chdata, u_int32_t blocksize)
M3_DEBUG(CHANGE, ("m3_pchan_setblocksize(dac=%d, blocksize=%d)\n",
ch->dac_idx, blocksize));
return (sndbuf_getblksz(ch->buffer));
return (ch->buffer->blksz);
}
static int
@ -709,7 +709,7 @@ m3_pchan_getptr_internal(struct sc_pchinfo *ch)
struct sc_info *sc = ch->parent;
u_int32_t hi, lo, bus_base, bus_crnt;
bus_base = sndbuf_getbufaddr(ch->buffer);
bus_base = ch->buffer->buf_addr;
hi = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTH);
lo = m3_rd_assp_data(sc, ch->dac_data + CDATA_HOST_SRC_CURRENTL);
bus_crnt = lo | (hi << 16);
@ -823,10 +823,10 @@ m3_rchan_init(kobj_t kobj, void *devinfo, struct snd_dbuf *b, struct pcm_channel
return (NULL);
}
M3_LOCK(sc);
ch->bufsize = sndbuf_getsize(ch->buffer);
ch->bufsize = ch->buffer->bufsize;
/* host dma buffer pointers */
bus_addr = sndbuf_getbufaddr(ch->buffer);
bus_addr = ch->buffer->buf_addr;
if (bus_addr & 3) {
device_printf(sc->dev, "m3_rchan_init unaligned bus_addr\n");
bus_addr = (bus_addr + 4) & ~3;
@ -968,7 +968,7 @@ m3_rchan_setblocksize(kobj_t kobj, void *chdata, u_int32_t blocksize)
M3_DEBUG(CHANGE, ("m3_rchan_setblocksize(adc=%d, blocksize=%d)\n",
ch->adc_idx, blocksize));
return (sndbuf_getblksz(ch->buffer));
return (ch->buffer->blksz);
}
static int
@ -1061,7 +1061,7 @@ m3_rchan_getptr_internal(struct sc_rchinfo *ch)
struct sc_info *sc = ch->parent;
u_int32_t hi, lo, bus_base, bus_crnt;
bus_base = sndbuf_getbufaddr(ch->buffer);
bus_base = ch->buffer->buf_addr;
hi = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTH);
lo = m3_rd_assp_data(sc, ch->adc_data + CDATA_HOST_SRC_CURRENTL);
bus_crnt = lo | (hi << 16);
@ -1162,7 +1162,7 @@ m3_handle_channel_intr:
pch->ptr = m3_pchan_getptr_internal(pch);
delta = pch->bufsize + pch->ptr - pch->prevptr;
delta %= pch->bufsize;
if (delta < sndbuf_getblksz(pch->buffer))
if (delta < pch->buffer->blksz)
continue;
pch->prevptr = pch->ptr;
M3_UNLOCK(sc);
@ -1176,7 +1176,7 @@ m3_handle_channel_intr:
rch->ptr = m3_rchan_getptr_internal(rch);
delta = rch->bufsize + rch->ptr - rch->prevptr;
delta %= rch->bufsize;
if (delta < sndbuf_getblksz(rch->buffer))
if (delta < rch->buffer->blksz)
continue;
rch->prevptr = rch->ptr;
M3_UNLOCK(sc);

2
sys/dev/sound/pci/neomagic.c
View file

@ -362,7 +362,7 @@ nmchan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c
sndbuf_setup(ch->buffer, (u_int8_t *)rman_get_virtual(sc->buf) + chnbuf, NM_BUFFSIZE);
if (bootverbose)
device_printf(sc->dev, "%s buf %p\n", (dir == PCMDIR_PLAY)?
"play" : "rec", sndbuf_getbuf(ch->buffer));
"play" : "rec", ch->buffer->buf);
ch->parent = sc;
ch->channel = c;
ch->dir = dir;

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

@ -584,7 +584,8 @@ esschan_trigger(kobj_t obj, void *data, int go)
ess_lock(sc);
switch (go) {
case PCMTRIG_START:
ess_dmasetup(sc, ch->hwch, sndbuf_getbufaddr(ch->buffer), sndbuf_getsize(ch->buffer), ch->dir);
ess_dmasetup(sc, ch->hwch, ch->buffer->buf_addr,
ch->buffer->bufsize, ch->dir);
ess_dmatrigger(sc, ch->hwch, 1);
ess_start(ch);
break;

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

@ -555,9 +555,9 @@ trpchan_trigger(kobj_t obj, void *data, int go)
ch->fms = 0;
ch->ec = 0;
ch->alpha = 0;
ch->lba = sndbuf_getbufaddr(ch->buffer);
ch->lba = ch->buffer->buf_addr;
ch->cso = 0;
ch->eso = (sndbuf_getsize(ch->buffer) / sndbuf_getalign(ch->buffer)) - 1;
ch->eso = (ch->buffer->bufsize / ch->buffer->align) - 1;
ch->rvol = ch->cvol = 0x7f;
ch->gvsel = 0;
ch->pan = 0;
@ -581,7 +581,7 @@ trpchan_getptr(kobj_t obj, void *data)
struct tr_chinfo *ch = data;
tr_rdch(ch);
return ch->cso * sndbuf_getalign(ch->buffer);
return ch->cso * ch->buffer->align;
}
static struct pcmchan_caps *
@ -680,7 +680,7 @@ trrchan_trigger(kobj_t obj, void *data, int go)
i = tr_rd(tr, TR_REG_DMAR11, 1) & 0x03;
tr_wr(tr, TR_REG_DMAR11, i | 0x54, 1);
/* set up base address */
tr_wr(tr, TR_REG_DMAR0, sndbuf_getbufaddr(ch->buffer), 4);
tr_wr(tr, TR_REG_DMAR0, ch->buffer->buf_addr, 4);
/* set up buffer size */
i = tr_rd(tr, TR_REG_DMAR4, 4) & ~0x00ffffff;
tr_wr(tr, TR_REG_DMAR4, i | (sndbuf_runsz(ch->buffer) - 1), 4);
@ -703,7 +703,7 @@ trrchan_getptr(kobj_t obj, void *data)
struct tr_info *tr = ch->parent;
/* return current byte offset of channel */
return tr_rd(tr, TR_REG_DMAR0, 4) - sndbuf_getbufaddr(ch->buffer);
return tr_rd(tr, TR_REG_DMAR0, 4) - ch->buffer->buf_addr;
}
static struct pcmchan_caps *

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

@ -385,7 +385,7 @@ via_buildsgdt(struct via_chinfo *ch)
uint32_t phys_addr, flag;
int i;
phys_addr = sndbuf_getbufaddr(ch->buffer);
phys_addr = ch->buffer->buf_addr;
for (i = 0; i < ch->blkcnt; i++) {
flag = (i == ch->blkcnt - 1) ? VIA_DMAOP_EOL : VIA_DMAOP_FLAG;
@ -568,8 +568,8 @@ via8233chan_setfragments(kobj_t obj, void *data,
blksz &= VIA_BLK_ALIGN;
if (blksz > (sndbuf_getmaxsize(ch->buffer) / VIA_SEGS_MIN))
blksz = sndbuf_getmaxsize(ch->buffer) / VIA_SEGS_MIN;
if (blksz > (ch->buffer->maxsize / VIA_SEGS_MIN))
blksz = ch->buffer->maxsize / VIA_SEGS_MIN;
if (blksz < VIA_BLK_MIN)
blksz = VIA_BLK_MIN;
if (blkcnt > VIA_SEGS_MAX)
@ -577,7 +577,7 @@ via8233chan_setfragments(kobj_t obj, void *data,
if (blkcnt < VIA_SEGS_MIN)
blkcnt = VIA_SEGS_MIN;
while ((blksz * blkcnt) > sndbuf_getmaxsize(ch->buffer)) {
while ((blksz * blkcnt) > ch->buffer->maxsize) {
if ((blkcnt >> 1) >= VIA_SEGS_MIN)
blkcnt >>= 1;
else if ((blksz >> 1) >= VIA_BLK_MIN)
@ -586,14 +586,14 @@ via8233chan_setfragments(kobj_t obj, void *data,
break;
}
if ((sndbuf_getblksz(ch->buffer) != blksz ||
sndbuf_getblkcnt(ch->buffer) != blkcnt) &&
if ((ch->buffer->blksz != blksz ||
ch->buffer->blkcnt != blkcnt) &&
sndbuf_resize(ch->buffer, blkcnt, blksz) != 0)
device_printf(via->dev, "%s: failed blksz=%u blkcnt=%u\n",
__func__, blksz, blkcnt);
ch->blksz = sndbuf_getblksz(ch->buffer);
ch->blkcnt = sndbuf_getblkcnt(ch->buffer);
ch->blksz = ch->buffer->blksz;
ch->blkcnt = ch->buffer->blkcnt;
return (0);
}
@ -850,8 +850,7 @@ via_poll_ticks(struct via_info *via)
if (ch->channel == NULL || ch->active == 0)
continue;
pollticks = ((uint64_t)hz * ch->blksz) /
((uint64_t)sndbuf_getalign(ch->buffer) *
sndbuf_getspd(ch->buffer));
((uint64_t)ch->buffer->align * ch->buffer->spd);
pollticks >>= 2;
if (pollticks > hz)
pollticks = hz;
@ -866,8 +865,7 @@ via_poll_ticks(struct via_info *via)
if (ch->channel == NULL || ch->active == 0)
continue;
pollticks = ((uint64_t)hz * ch->blksz) /
((uint64_t)sndbuf_getalign(ch->buffer) *
sndbuf_getspd(ch->buffer));
((uint64_t)ch->buffer->align * ch->buffer->spd);
pollticks >>= 2;
if (pollticks > hz)
pollticks = hz;
@ -900,8 +898,8 @@ via8233chan_trigger(kobj_t obj, void* data, int go)
ch->ptr = 0;
ch->prevptr = 0;
pollticks = ((uint64_t)hz * ch->blksz) /
((uint64_t)sndbuf_getalign(ch->buffer) *
sndbuf_getspd(ch->buffer));
((uint64_t)ch->buffer->align *
ch->buffer->spd);
pollticks >>= 2;
if (pollticks > hz)
pollticks = hz;

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

@ -226,8 +226,8 @@ via_buildsgdt(struct via_chinfo *ch)
* is feeding.
*/
seg_size = ch->blksz;
segs = sndbuf_getsize(ch->buffer) / seg_size;
phys_addr = sndbuf_getbufaddr(ch->buffer);
segs = ch->buffer->bufsize / seg_size;
phys_addr = ch->buffer->buf_addr;
for (i = 0; i < segs; i++) {
flag = (i == segs - 1)? VIA_DMAOP_EOL : VIA_DMAOP_FLAG;
@ -385,7 +385,7 @@ viachan_getptr(kobj_t obj, void *data)
seg = SEGS_PER_CHAN;
/* Now work out offset: seg less count */
ptr = (seg * sndbuf_getsize(ch->buffer) / SEGS_PER_CHAN) - len;
ptr = (seg * ch->buffer->bufsize / SEGS_PER_CHAN) - len;
if (ch->dir == PCMDIR_REC) {
/* DMA appears to operate on memory 'lines' of 32 bytes */
/* so don't return any part line - it isn't in RAM yet */

12
sys/dev/sound/pci/vibes.c
View file

@ -328,9 +328,9 @@ svrchan_trigger(kobj_t obj, void *data, int go)
sv_indirect_set(sc, SV_REG_FORMAT, v);
/* Program DMA */
count = sndbuf_getsize(ch->buffer) / 2; /* DMAC uses words */
count = ch->buffer->bufsize / 2; /* DMAC uses words */
sv_dma_set_config(sc->dmac_st, sc->dmac_sh,
sndbuf_getbufaddr(ch->buffer),
ch->buffer->buf_addr,
count - 1,
SV_DMA_MODE_AUTO | SV_DMA_MODE_RD);
count = count / SV_INTR_PER_BUFFER - 1;
@ -360,7 +360,7 @@ svrchan_getptr(kobj_t obj, void *data)
struct sc_info *sc = ch->parent;
u_int32_t sz, remain;
sz = sndbuf_getsize(ch->buffer);
sz = ch->buffer->bufsize;
/* DMAC uses words */
remain = (sv_dma_get_count(sc->dmac_st, sc->dmac_sh) + 1) * 2;
return sz - remain;
@ -404,9 +404,9 @@ svpchan_trigger(kobj_t obj, void *data, int go)
sv_indirect_set(sc, SV_REG_FORMAT, v);
/* Program DMA */
count = sndbuf_getsize(ch->buffer);
count = ch->buffer->bufsize;
sv_dma_set_config(sc->dmaa_st, sc->dmaa_sh,
sndbuf_getbufaddr(ch->buffer),
ch->buffer->buf_addr,
count - 1,
SV_DMA_MODE_AUTO | SV_DMA_MODE_WR);
count = count / SV_INTR_PER_BUFFER - 1;
@ -437,7 +437,7 @@ svpchan_getptr(kobj_t obj, void *data)
struct sc_info *sc = ch->parent;
u_int32_t sz, remain;
sz = sndbuf_getsize(ch->buffer);
sz = ch->buffer->bufsize;
/* DMAA uses bytes */
remain = sv_dma_get_count(sc->dmaa_st, sc->dmaa_sh) + 1;
return (sz - remain);

144
sys/dev/sound/pcm/buffer.c
View file

@ -59,12 +59,6 @@ sndbuf_destroy(struct snd_dbuf *b)
free(b, M_DEVBUF);
}
bus_addr_t
sndbuf_getbufaddr(struct snd_dbuf *buf)
{
return (buf->buf_addr);
}
static void
sndbuf_setmap(void *arg, bus_dma_segment_t *segs, int nseg, int error)
{
@ -146,7 +140,7 @@ sndbuf_free(struct snd_dbuf *b)
} else
free(b->buf, M_DEVBUF);
}
seldrain(sndbuf_getsel(b));
seldrain(&b->sel);
b->tmpbuf = NULL;
b->shadbuf = NULL;
@ -277,7 +271,7 @@ sndbuf_clear(struct snd_dbuf *b, unsigned int length)
data = sndbuf_zerodata(b->fmt);
i = sndbuf_getfreeptr(b);
p = sndbuf_getbuf(b);
p = b->buf;
for (; length > 0; length--, i++)
p[i % b->bufsize] = data;
}
@ -291,7 +285,7 @@ void
sndbuf_fillsilence(struct snd_dbuf *b)
{
if (b->bufsize > 0)
memset(sndbuf_getbuf(b), sndbuf_zerodata(b->fmt), b->bufsize);
memset(b->buf, sndbuf_zerodata(b->fmt), b->bufsize);
b->rp = 0;
b->rl = b->bufsize;
}
@ -300,7 +294,7 @@ void
sndbuf_fillsilence_rl(struct snd_dbuf *b, u_int rl)
{
if (b->bufsize > 0)
memset(sndbuf_getbuf(b), sndbuf_zerodata(b->fmt), b->bufsize);
memset(b->buf, sndbuf_zerodata(b->fmt), b->bufsize);
b->rp = 0;
b->rl = min(b->bufsize, rl);
}
@ -337,12 +331,6 @@ sndbuf_reset(struct snd_dbuf *b)
sndbuf_clearshadow(b);
}
u_int32_t
sndbuf_getfmt(struct snd_dbuf *b)
{
return b->fmt;
}
int
sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt)
{
@ -352,60 +340,12 @@ sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt)
return 0;
}
unsigned int
sndbuf_getspd(struct snd_dbuf *b)
{
return b->spd;
}
void
sndbuf_setspd(struct snd_dbuf *b, unsigned int spd)
{
b->spd = spd;
}
unsigned int
sndbuf_getalign(struct snd_dbuf *b)
{
return (b->align);
}
unsigned int
sndbuf_getblkcnt(struct snd_dbuf *b)
{
return b->blkcnt;
}
void
sndbuf_setblkcnt(struct snd_dbuf *b, unsigned int blkcnt)
{
b->blkcnt = blkcnt;
}
unsigned int
sndbuf_getblksz(struct snd_dbuf *b)
{
return b->blksz;
}
void
sndbuf_setblksz(struct snd_dbuf *b, unsigned int blksz)
{
b->blksz = blksz;
}
unsigned int
sndbuf_getbps(struct snd_dbuf *b)
{
return b->bps;
}
void *
sndbuf_getbuf(struct snd_dbuf *b)
{
return b->buf;
}
void *
sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs)
{
@ -414,24 +354,6 @@ sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs)
return b->buf + ofs;
}
unsigned int
sndbuf_getsize(struct snd_dbuf *b)
{
return b->bufsize;
}
unsigned int
sndbuf_getmaxsize(struct snd_dbuf *b)
{
return b->maxsize;
}
unsigned int
sndbuf_getallocsize(struct snd_dbuf *b)
{
return b->allocsize;
}
unsigned int
sndbuf_runsz(struct snd_dbuf *b)
{
@ -444,37 +366,12 @@ sndbuf_setrun(struct snd_dbuf *b, int go)
b->dl = go? b->blksz : 0;
}
struct selinfo *
sndbuf_getsel(struct snd_dbuf *b)
{
return &b->sel;
}
/************************************************************/
unsigned int
sndbuf_getxrun(struct snd_dbuf *b)
{
return b->xrun;
}
void
sndbuf_setxrun(struct snd_dbuf *b, unsigned int xrun)
{
b->xrun = xrun;
}
unsigned int
sndbuf_gethwptr(struct snd_dbuf *b)
{
return b->hp;
}
void
sndbuf_sethwptr(struct snd_dbuf *b, unsigned int ptr)
{
b->hp = ptr;
}
unsigned int
sndbuf_getready(struct snd_dbuf *b)
{
@ -514,38 +411,13 @@ sndbuf_getblocks(struct snd_dbuf *b)
return b->total / b->blksz;
}
u_int64_t
sndbuf_getprevblocks(struct snd_dbuf *b)
{
return b->prev_total / b->blksz;
}
u_int64_t
sndbuf_gettotal(struct snd_dbuf *b)
{
return b->total;
}
u_int64_t
sndbuf_getprevtotal(struct snd_dbuf *b)
{
return b->prev_total;
}
void
sndbuf_updateprevtotal(struct snd_dbuf *b)
{
b->prev_total = b->total;
}
unsigned int
sndbuf_xbytes(unsigned int v, struct snd_dbuf *from, struct snd_dbuf *to)
{
if (from == NULL || to == NULL || v == 0)
return 0;
return snd_xbytes(v, sndbuf_getalign(from) * sndbuf_getspd(from),
sndbuf_getalign(to) * sndbuf_getspd(to));
return snd_xbytes(v, from->align * from->spd, to->align * to->spd);
}
u_int8_t
@ -585,7 +457,7 @@ sndbuf_acquire(struct snd_dbuf *b, u_int8_t *from, unsigned int count)
b->total += count;
if (from != NULL) {
while (count > 0) {
l = min(count, sndbuf_getsize(b) - sndbuf_getfreeptr(b));
l = min(count, b->bufsize - sndbuf_getfreeptr(b));
bcopy(from, sndbuf_getbufofs(b, sndbuf_getfreeptr(b)), l);
from += l;
b->rl += l;
@ -621,7 +493,7 @@ sndbuf_dispose(struct snd_dbuf *b, u_int8_t *to, unsigned int count)
KASSERT((b->rl >= 0) && (b->rl <= b->bufsize), ("%s: b->rl invalid %d", __func__, b->rl));
if (to != NULL) {
while (count > 0) {
l = min(count, sndbuf_getsize(b) - sndbuf_getreadyptr(b));
l = min(count, b->bufsize - sndbuf_getreadyptr(b));
bcopy(sndbuf_getbufofs(b, sndbuf_getreadyptr(b)), to, l);
to += l;
b->rl -= l;
@ -666,7 +538,7 @@ sndbuf_feed(struct snd_dbuf *from, struct snd_dbuf *to, struct pcm_channel *chan
if (sndbuf_getfree(to) < count)
return (EINVAL);
maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(to));
maxfeed = SND_FXROUND(SND_FXDIV_MAX, to->align);
do {
cnt = FEEDER_FEED(feeder, channel, to->tmpbuf,

22
sys/dev/sound/pcm/buffer.h
View file

@ -69,43 +69,21 @@ void sndbuf_fillsilence_rl(struct snd_dbuf *b, u_int rl);
void sndbuf_softreset(struct snd_dbuf *b);
void sndbuf_clearshadow(struct snd_dbuf *b);
u_int32_t sndbuf_getfmt(struct snd_dbuf *b);
int sndbuf_setfmt(struct snd_dbuf *b, u_int32_t fmt);
unsigned int sndbuf_getspd(struct snd_dbuf *b);
void sndbuf_setspd(struct snd_dbuf *b, unsigned int spd);
unsigned int sndbuf_getbps(struct snd_dbuf *b);
bus_addr_t sndbuf_getbufaddr(struct snd_dbuf *buf);
void *sndbuf_getbuf(struct snd_dbuf *b);
void *sndbuf_getbufofs(struct snd_dbuf *b, unsigned int ofs);
unsigned int sndbuf_getsize(struct snd_dbuf *b);
unsigned int sndbuf_getmaxsize(struct snd_dbuf *b);
unsigned int sndbuf_getallocsize(struct snd_dbuf *b);
unsigned int sndbuf_getalign(struct snd_dbuf *b);
unsigned int sndbuf_getblkcnt(struct snd_dbuf *b);
void sndbuf_setblkcnt(struct snd_dbuf *b, unsigned int blkcnt);
unsigned int sndbuf_getblksz(struct snd_dbuf *b);
void sndbuf_setblksz(struct snd_dbuf *b, unsigned int blksz);
unsigned int sndbuf_runsz(struct snd_dbuf *b);
void sndbuf_setrun(struct snd_dbuf *b, int go);
struct selinfo *sndbuf_getsel(struct snd_dbuf *b);
unsigned int sndbuf_getxrun(struct snd_dbuf *b);
void sndbuf_setxrun(struct snd_dbuf *b, unsigned int xrun);
unsigned int sndbuf_gethwptr(struct snd_dbuf *b);
void sndbuf_sethwptr(struct snd_dbuf *b, unsigned int ptr);
unsigned int sndbuf_getfree(struct snd_dbuf *b);
unsigned int sndbuf_getfreeptr(struct snd_dbuf *b);
unsigned int sndbuf_getready(struct snd_dbuf *b);
unsigned int sndbuf_getreadyptr(struct snd_dbuf *b);
u_int64_t sndbuf_getblocks(struct snd_dbuf *b);
u_int64_t sndbuf_getprevblocks(struct snd_dbuf *b);
u_int64_t sndbuf_gettotal(struct snd_dbuf *b);
u_int64_t sndbuf_getprevtotal(struct snd_dbuf *b);
unsigned int sndbuf_xbytes(unsigned int v, struct snd_dbuf *from, struct snd_dbuf *to);
u_int8_t sndbuf_zerodata(u_int32_t fmt);
void sndbuf_updateprevtotal(struct snd_dbuf *b);
int sndbuf_acquire(struct snd_dbuf *b, u_int8_t *from, unsigned int count);
int sndbuf_dispose(struct snd_dbuf *b, u_int8_t *to, unsigned int count);

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

@ -280,10 +280,10 @@ chn_polltrigger(struct pcm_channel *c)
CHN_LOCKASSERT(c);
if (c->flags & CHN_F_MMAP) {
if (sndbuf_getprevtotal(bs) < c->lw)
if (bs->prev_total < c->lw)
delta = c->lw;
else
delta = sndbuf_gettotal(bs) - sndbuf_getprevtotal(bs);
delta = bs->total - bs->prev_total;
} else {
if (c->direction == PCMDIR_PLAY)
delta = sndbuf_getfree(bs);
@ -299,7 +299,7 @@ chn_pollreset(struct pcm_channel *c)
{
CHN_LOCKASSERT(c);
sndbuf_updateprevtotal(c->bufsoft);
c->bufsoft->prev_total = c->bufsoft->total;
}
static void
@ -314,8 +314,8 @@ chn_wakeup(struct pcm_channel *c)
if (CHN_EMPTY(c, children.busy)) {
KNOTE_LOCKED(&bs->sel.si_note, 0);
if (SEL_WAITING(sndbuf_getsel(bs)) && chn_polltrigger(c))
selwakeuppri(sndbuf_getsel(bs), PRIBIO);
if (SEL_WAITING(&bs->sel) && chn_polltrigger(c))
selwakeuppri(&bs->sel, PRIBIO);
CHN_BROADCAST(&c->intr_cv);
} else {
CHN_FOREACH(ch, c, children.busy) {
@ -354,22 +354,22 @@ chn_dmaupdate(struct pcm_channel *c)
struct snd_dbuf *b = c->bufhard;
unsigned int delta, old, hwptr, amt;
KASSERT(sndbuf_getsize(b) > 0, ("bufsize == 0"));
KASSERT(b->bufsize > 0, ("bufsize == 0"));
CHN_LOCKASSERT(c);
old = sndbuf_gethwptr(b);
old = b->hp;
hwptr = chn_getptr(c);
delta = (sndbuf_getsize(b) + hwptr - old) % sndbuf_getsize(b);
sndbuf_sethwptr(b, hwptr);
delta = (b->bufsize + hwptr - old) % b->bufsize;
b->hp = hwptr;
if (c->direction == PCMDIR_PLAY) {
amt = min(delta, sndbuf_getready(b));
amt -= amt % sndbuf_getalign(b);
amt -= amt % b->align;
if (amt > 0)
sndbuf_dispose(b, NULL, amt);
} else {
amt = min(delta, sndbuf_getfree(b));
amt -= amt % sndbuf_getalign(b);
amt -= amt % b->align;
if (amt > 0)
sndbuf_acquire(b, NULL, amt);
}
@ -397,8 +397,7 @@ chn_wrfeed(struct pcm_channel *c)
sndbuf_acquire(bs, NULL, sndbuf_getfree(bs));
wasfree = sndbuf_getfree(b);
want = min(sndbuf_getsize(b),
imax(0, sndbuf_xbytes(sndbuf_getsize(bs), bs, b) -
want = min(b->bufsize, imax(0, sndbuf_xbytes(bs->bufsize, bs, b) -
sndbuf_getready(b)));
amt = min(wasfree, want);
if (amt > 0)
@ -456,7 +455,7 @@ chn_write(struct pcm_channel *c, struct uio *buf)
*/
while (ret == 0 && sz > 0) {
p = sndbuf_getfreeptr(bs);
t = min(sz, sndbuf_getsize(bs) - p);
t = min(sz, bs->bufsize - p);
off = sndbuf_getbufofs(bs, p);
CHN_UNLOCK(c);
ret = uiomove(off, t, buf);
@ -578,7 +577,7 @@ chn_read(struct pcm_channel *c, struct uio *buf)
*/
while (ret == 0 && sz > 0) {
p = sndbuf_getreadyptr(bs);
t = min(sz, sndbuf_getsize(bs) - p);
t = min(sz, bs->bufsize - p);
off = sndbuf_getbufofs(bs, p);
CHN_UNLOCK(c);
ret = uiomove(off, t, buf);
@ -664,7 +663,7 @@ chn_start(struct pcm_channel *c, int force)
pb = CHN_BUF_PARENT(c, b);
i = sndbuf_xbytes(sndbuf_getready(bs), bs, pb);
j = sndbuf_getalign(pb);
j = pb->align;
}
}
if (snd_verbose > 3 && CHN_EMPTY(c, children))
@ -687,7 +686,7 @@ chn_start(struct pcm_channel *c, int force)
if (c->parentchannel == NULL) {
if (c->direction == PCMDIR_PLAY)
sndbuf_fillsilence_rl(b,
sndbuf_xbytes(sndbuf_getsize(bs), bs, b));
sndbuf_xbytes(bs->bufsize, bs, b));
if (snd_verbose > 3)
device_printf(c->dev,
"%s(): %s starting! (%s/%s) "
@ -700,8 +699,8 @@ chn_start(struct pcm_channel *c, int force)
"running",
sndbuf_getready(b),
force, i, j, c->timeout,
(sndbuf_getsize(b) * 1000) /
(sndbuf_getalign(b) * sndbuf_getspd(b)));
(b->bufsize * 1000) /
(b->align * b->spd));
}
err = chn_trigger(c, PCMTRIG_START);
}
@ -760,7 +759,7 @@ chn_sync(struct pcm_channel *c, int threshold)
syncdelay = chn_syncdelay;
if (syncdelay < 0 && (threshold > 0 || sndbuf_getready(bs) > 0))
minflush += sndbuf_xbytes(sndbuf_getsize(b), b, bs);
minflush += sndbuf_xbytes(b->bufsize, b, bs);
/*
* Append (0-1000) millisecond trailing buffer (if needed)
@ -768,10 +767,10 @@ chn_sync(struct pcm_channel *c, int threshold)
* to avoid audible truncation.
*/
if (syncdelay > 0)
minflush += (sndbuf_getalign(bs) * sndbuf_getspd(bs) *
minflush += (bs->align * bs->spd *
((syncdelay > 1000) ? 1000 : syncdelay)) / 1000;
minflush -= minflush % sndbuf_getalign(bs);
minflush -= minflush % bs->align;
if (minflush > 0) {
threshold = min(minflush, sndbuf_getfree(bs));
@ -782,14 +781,14 @@ chn_sync(struct pcm_channel *c, int threshold)
resid = sndbuf_getready(bs);
residp = resid;
blksz = sndbuf_getblksz(b);
blksz = b->blksz;
if (blksz < 1) {
device_printf(c->dev,
"%s(): WARNING: blksz < 1 ! maxsize=%d [%d/%d/%d]\n",
__func__, sndbuf_getmaxsize(b), sndbuf_getsize(b),
sndbuf_getblksz(b), sndbuf_getblkcnt(b));
if (sndbuf_getblkcnt(b) > 0)
blksz = sndbuf_getsize(b) / sndbuf_getblkcnt(b);
__func__, b->maxsize, b->bufsize,
b->blksz, b->blkcnt);
if (b->blkcnt > 0)
blksz = b->bufsize / b->blkcnt;
if (blksz < 1)
blksz = 1;
}
@ -875,7 +874,7 @@ chn_poll(struct pcm_channel *c, int ev, struct thread *td)
chn_pollreset(c);
ret = ev;
} else
selrecord(td, sndbuf_getsel(bs));
selrecord(td, &bs->sel);
return (ret);
}
@ -1286,7 +1285,7 @@ chn_init(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls,
goto fail;
}
if ((sndbuf_getsize(b) == 0) && ((c->flags & CHN_F_VIRTUAL) == 0)) {
if (b->bufsize == 0 && ((c->flags & CHN_F_VIRTUAL) == 0)) {
device_printf(d->dev, "%s(): hardware buffer's size is 0\n",
__func__);
goto fail;
@ -1304,7 +1303,7 @@ chn_init(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls,
* seems to only come into existence in sndbuf_resize().
*/
if (c->direction == PCMDIR_PLAY) {
bs->sl = sndbuf_getmaxsize(bs);
bs->sl = bs->maxsize;
bs->shadbuf = malloc(bs->sl, M_DEVBUF, M_WAITOK);
}
@ -1321,8 +1320,8 @@ chn_init(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls,
if ((c->flags & CHN_F_VIRTUAL) == 0) {
CHN_INSERT_SORT_ASCEND(d, c, channels.pcm.primary);
/* Initialize the *vchanrate/vchanformat parameters. */
*vchanrate = sndbuf_getspd(c->bufsoft);
*vchanformat = sndbuf_getfmt(c->bufsoft);
*vchanrate = c->bufsoft->spd;
*vchanformat = c->bufsoft->fmt;
}
return (c);
@ -1900,20 +1899,20 @@ chn_resizebuf(struct pcm_channel *c, int latency,
b = c->bufhard;
if (!(blksz == 0 || blkcnt == -1) &&
(blksz < 16 || blksz < sndbuf_getalign(bs) || blkcnt < 2 ||
(blksz < 16 || blksz < bs->align || blkcnt < 2 ||
(blksz * blkcnt) > CHN_2NDBUFMAXSIZE))
return EINVAL;
chn_calclatency(c->direction, latency, sndbuf_getalign(bs),
sndbuf_getalign(bs) * sndbuf_getspd(bs), CHN_2NDBUFMAXSIZE,
chn_calclatency(c->direction, latency, bs->align,
bs->align * bs->spd, CHN_2NDBUFMAXSIZE,
&sblksz, &sblkcnt);
if (blksz == 0 || blkcnt == -1) {
if (blkcnt == -1)
c->flags &= ~CHN_F_HAS_SIZE;
if (c->flags & CHN_F_HAS_SIZE) {
blksz = sndbuf_getblksz(bs);
blkcnt = sndbuf_getblkcnt(bs);
blksz = bs->blksz;
blkcnt = bs->blkcnt;
}
} else
c->flags |= CHN_F_HAS_SIZE;
@ -1926,7 +1925,7 @@ chn_resizebuf(struct pcm_channel *c, int latency,
* defeat the purpose of having custom control. The least
* we can do is round it to the nearest ^2 and align it.
*/
sblksz = round_blksz(blksz, sndbuf_getalign(bs));
sblksz = round_blksz(blksz, bs->align);
sblkcnt = round_pow2(blkcnt);
}
@ -1939,49 +1938,46 @@ chn_resizebuf(struct pcm_channel *c, int latency,
CHN_LOCK(c);
if (c->direction == PCMDIR_PLAY) {
limit = (pb != NULL) ?
sndbuf_xbytes(sndbuf_getsize(pb), pb, bs) : 0;
sndbuf_xbytes(pb->bufsize, pb, bs) : 0;
} else {
limit = (pb != NULL) ?
sndbuf_xbytes(sndbuf_getblksz(pb), pb, bs) * 2 : 0;
sndbuf_xbytes(pb->blksz, pb, bs) * 2 : 0;
}
} else {
hblkcnt = 2;
if (c->flags & CHN_F_HAS_SIZE) {
hblksz = round_blksz(sndbuf_xbytes(sblksz, bs, b),
sndbuf_getalign(b));
hblkcnt = round_pow2(sndbuf_getblkcnt(bs));
b->align);
hblkcnt = round_pow2(bs->blkcnt);
} else
chn_calclatency(c->direction, latency,
sndbuf_getalign(b),
sndbuf_getalign(b) * sndbuf_getspd(b),
b->align, b->align * b->spd,
CHN_2NDBUFMAXSIZE, &hblksz, &hblkcnt);
if ((hblksz << 1) > sndbuf_getmaxsize(b))
hblksz = round_blksz(sndbuf_getmaxsize(b) >> 1,
sndbuf_getalign(b));
if ((hblksz << 1) > b->maxsize)
hblksz = round_blksz(b->maxsize >> 1, b->align);
while ((hblksz * hblkcnt) > sndbuf_getmaxsize(b)) {
while ((hblksz * hblkcnt) > b->maxsize) {
if (hblkcnt < 4)
hblksz >>= 1;
else
hblkcnt >>= 1;
}
hblksz -= hblksz % sndbuf_getalign(b);
hblksz -= hblksz % b->align;
CHN_UNLOCK(c);
if (chn_usefrags == 0 ||
CHANNEL_SETFRAGMENTS(c->methods, c->devinfo,
hblksz, hblkcnt) != 0)
sndbuf_setblksz(b, CHANNEL_SETBLOCKSIZE(c->methods,
c->devinfo, hblksz));
b->blksz = CHANNEL_SETBLOCKSIZE(c->methods,
c->devinfo, hblksz);
CHN_LOCK(c);
if (!CHN_EMPTY(c, children)) {
nsblksz = round_blksz(
sndbuf_xbytes(sndbuf_getblksz(b), b, bs),
sndbuf_getalign(bs));
nsblkcnt = sndbuf_getblkcnt(b);
sndbuf_xbytes(b->blksz, b, bs), bs->align);
nsblkcnt = b->blkcnt;
if (c->direction == PCMDIR_PLAY) {
do {
nsblkcnt--;
@ -1993,7 +1989,7 @@ chn_resizebuf(struct pcm_channel *c, int latency,
sblkcnt = nsblkcnt;
limit = 0;
} else
limit = sndbuf_xbytes(sndbuf_getblksz(b), b, bs) * 2;
limit = sndbuf_xbytes(b->blksz, b, bs) * 2;
}
if (limit > CHN_2NDBUFMAXSIZE)
@ -2009,10 +2005,10 @@ chn_resizebuf(struct pcm_channel *c, int latency,
sblkcnt >>= 1;
}
sblksz -= sblksz % sndbuf_getalign(bs);
sblksz -= sblksz % bs->align;
if (sndbuf_getblkcnt(bs) != sblkcnt || sndbuf_getblksz(bs) != sblksz ||
sndbuf_getsize(bs) != (sblkcnt * sblksz)) {
if (bs->blkcnt != sblkcnt || bs->blksz != sblksz ||
bs->bufsize != (sblkcnt * sblksz)) {
ret = sndbuf_remalloc(bs, sblkcnt, sblksz);
if (ret != 0) {
device_printf(c->dev, "%s(): Failed: %d %d\n",
@ -2024,8 +2020,8 @@ chn_resizebuf(struct pcm_channel *c, int latency,
/*
* Interrupt timeout
*/
c->timeout = ((u_int64_t)hz * sndbuf_getsize(bs)) /
((u_int64_t)sndbuf_getspd(bs) * sndbuf_getalign(bs));
c->timeout = ((u_int64_t)hz * bs->bufsize) /
((u_int64_t)bs->spd * bs->align);
if (c->parentchannel != NULL)
c->timeout = min(c->timeout, c->parentchannel->timeout);
if (c->timeout < 1)
@ -2035,7 +2031,7 @@ chn_resizebuf(struct pcm_channel *c, int latency,
* OSSv4 docs: "By default OSS will set the low water level equal
* to the fragment size which is optimal in most cases."
*/
c->lw = sndbuf_getblksz(bs);
c->lw = bs->blksz;
chn_resetbuf(c);
if (snd_verbose > 3)
@ -2044,10 +2040,10 @@ chn_resizebuf(struct pcm_channel *c, int latency,
__func__, CHN_DIRSTR(c),
(c->flags & CHN_F_VIRTUAL) ? "virtual" : "hardware",
c->timeout,
sndbuf_getsize(b), sndbuf_getblksz(b),
sndbuf_getblkcnt(b),
sndbuf_getsize(bs), sndbuf_getblksz(bs),
sndbuf_getblkcnt(bs), limit);
b->bufsize, b->blksz,
b->blkcnt,
bs->bufsize, bs->blksz,
bs->blkcnt, limit);
return 0;
}
@ -2090,7 +2086,7 @@ chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed)
sndbuf_setspd(c->bufhard, CHANNEL_SETSPEED(c->methods, c->devinfo,
hwspeed));
hwspeed = sndbuf_getspd(c->bufhard);
hwspeed = c->bufhard->spd;
delta = (hwspeed > speed) ? (hwspeed - speed) : (speed - hwspeed);
@ -2100,8 +2096,7 @@ chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed)
ret = feeder_chain(c);
if (ret == 0)
ret = CHANNEL_SETFORMAT(c->methods, c->devinfo,
sndbuf_getfmt(c->bufhard));
ret = CHANNEL_SETFORMAT(c->methods, c->devinfo, c->bufhard->fmt);
if (ret == 0)
ret = chn_resizebuf(c, -2, 0, 0);
@ -2344,7 +2339,7 @@ chn_getptr(struct pcm_channel *c)
CHN_LOCKASSERT(c);
hwptr = (CHN_STARTED(c)) ? CHANNEL_GETPTR(c->methods, c->devinfo) : 0;
return (hwptr - (hwptr % sndbuf_getalign(c->bufhard)));
return (hwptr - (hwptr % c->bufhard->align));
}
struct pcmchan_caps *

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

@ -837,13 +837,13 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
if (wrch) {
CHN_LOCK(wrch);
chn_setblocksize(wrch, 2, p->play_size);
p->play_size = sndbuf_getblksz(wrch->bufsoft);
p->play_size = wrch->bufsoft->blksz;
CHN_UNLOCK(wrch);
}
if (rdch) {
CHN_LOCK(rdch);
chn_setblocksize(rdch, 2, p->rec_size);
p->rec_size = sndbuf_getblksz(rdch->bufsoft);
p->rec_size = rdch->bufsoft->blksz;
CHN_UNLOCK(rdch);
}
PCM_RELEASE_QUICK(d);
@ -855,12 +855,12 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
if (wrch) {
CHN_LOCK(wrch);
p->play_size = sndbuf_getblksz(wrch->bufsoft);
p->play_size = wrch->bufsoft->blksz;
CHN_UNLOCK(wrch);
}
if (rdch) {
CHN_LOCK(rdch);
p->rec_size = sndbuf_getblksz(rdch->bufsoft);
p->rec_size = rdch->bufsoft->blksz;
CHN_UNLOCK(rdch);
}
}
@ -975,8 +975,8 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
pcaps? pcaps->minspeed : 0);
p->rate_max = min(rcaps? rcaps->maxspeed : 1000000,
pcaps? pcaps->maxspeed : 1000000);
p->bufsize = min(rdch? sndbuf_getsize(rdch->bufsoft) : 1000000,
wrch? sndbuf_getsize(wrch->bufsoft) : 1000000);
p->bufsize = min(rdch? rdch->bufsoft->bufsize : 1000000,
wrch? wrch->bufsoft->bufsize : 1000000);
/* XXX bad on sb16 */
p->formats = (rdch? chn_getformats(rdch) : 0xffffffff) &
(wrch? chn_getformats(wrch) : 0xffffffff);
@ -1079,7 +1079,7 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
chn = wrch ? wrch : rdch;
if (chn) {
CHN_LOCK(chn);
*arg_i = sndbuf_getblksz(chn->bufsoft);
*arg_i = chn->bufsoft->blksz;
CHN_UNLOCK(chn);
} else {
*arg_i = 0;
@ -1317,8 +1317,8 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
if (rdch) {
CHN_LOCK(rdch);
ret = chn_setblocksize(rdch, maxfrags, fragsz);
r_maxfrags = sndbuf_getblkcnt(rdch->bufsoft);
r_fragsz = sndbuf_getblksz(rdch->bufsoft);
r_maxfrags = rdch->bufsoft->blkcnt;
r_fragsz = rdch->bufsoft->blksz;
CHN_UNLOCK(rdch);
} else {
r_maxfrags = maxfrags;
@ -1327,8 +1327,8 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
if (wrch && ret == 0) {
CHN_LOCK(wrch);
ret = chn_setblocksize(wrch, maxfrags, fragsz);
maxfrags = sndbuf_getblkcnt(wrch->bufsoft);
fragsz = sndbuf_getblksz(wrch->bufsoft);
maxfrags = wrch->bufsoft->blkcnt;
fragsz = wrch->bufsoft->blksz;
CHN_UNLOCK(wrch);
} else { /* use whatever came from the read channel */
maxfrags = r_maxfrags;
@ -1354,9 +1354,9 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
CHN_LOCK(rdch);
a->bytes = sndbuf_getready(bs);
a->fragments = a->bytes / sndbuf_getblksz(bs);
a->fragstotal = sndbuf_getblkcnt(bs);
a->fragsize = sndbuf_getblksz(bs);
a->fragments = a->bytes / bs->blksz;
a->fragstotal = bs->blkcnt;
a->fragsize = bs->blksz;
CHN_UNLOCK(rdch);
} else
ret = EINVAL;
@ -1372,9 +1372,9 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
CHN_LOCK(wrch);
a->bytes = sndbuf_getfree(bs);
a->fragments = a->bytes / sndbuf_getblksz(bs);
a->fragstotal = sndbuf_getblkcnt(bs);
a->fragsize = sndbuf_getblksz(bs);
a->fragments = a->bytes / bs->blksz;
a->fragstotal = bs->blkcnt;
a->fragsize = bs->blksz;
CHN_UNLOCK(wrch);
} else
ret = EINVAL;
@ -1388,7 +1388,7 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
struct snd_dbuf *bs = rdch->bufsoft;
CHN_LOCK(rdch);
a->bytes = sndbuf_gettotal(bs);
a->bytes = bs->total;
a->blocks = sndbuf_getblocks(bs) - rdch->blocks;
a->ptr = sndbuf_getfreeptr(bs);
rdch->blocks = sndbuf_getblocks(bs);
@ -1405,7 +1405,7 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
struct snd_dbuf *bs = wrch->bufsoft;
CHN_LOCK(wrch);
a->bytes = sndbuf_gettotal(bs);
a->bytes = bs->total;
a->blocks = sndbuf_getblocks(bs) - wrch->blocks;
a->ptr = sndbuf_getreadyptr(bs);
wrch->blocks = sndbuf_getblocks(bs);
@ -1692,8 +1692,8 @@ dsp_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode,
CHN_LOCK(chn);
bs = chn->bufsoft;
oc->samples = sndbuf_gettotal(bs) / sndbuf_getalign(bs);
oc->fifo_samples = sndbuf_getready(bs) / sndbuf_getalign(bs);
oc->samples = bs->total / bs->align;
oc->fifo_samples = sndbuf_getready(bs) / bs->align;
CHN_UNLOCK(chn);
}
break;
@ -1994,7 +1994,7 @@ dsp_mmap_single(struct cdev *i_dev, vm_ooffset_t *offset,
c = ((nprot & PROT_WRITE) != 0) ? wrch : rdch;
if (c == NULL || (c->flags & CHN_F_MMAP_INVALID) ||
(*offset + size) > sndbuf_getallocsize(c->bufsoft) ||
(*offset + size) > c->bufsoft->allocsize ||
(wrch != NULL && (wrch->flags & CHN_F_MMAP_INVALID)) ||
(rdch != NULL && (rdch->flags & CHN_F_MMAP_INVALID))) {
dsp_unlock_chans(priv, FREAD | FWRITE);

8
sys/dev/sound/pcm/feeder.c
View file

@ -433,9 +433,7 @@ feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u
offset, count, l, ch->feedcount);
if (ch->feedcount == 1) {
memset(buffer,
sndbuf_zerodata(sndbuf_getfmt(src)),
offset);
memset(buffer, sndbuf_zerodata(src->fmt), offset);
if (l > 0)
sndbuf_dispose(src, buffer + offset, l);
else
@ -443,9 +441,7 @@ feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u
} else {
if (l > 0)
sndbuf_dispose(src, buffer, l);
memset(buffer + l,
sndbuf_zerodata(sndbuf_getfmt(src)),
offset);
memset(buffer + l, sndbuf_zerodata(src->fmt), offset);
if (!(ch->flags & CHN_F_CLOSING))
ch->xruns++;
}

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

@ -695,11 +695,11 @@ feeder_chain(struct pcm_channel *c)
cdesc.origin.rate = c->speed;
cdesc.target.afmt = hwfmt;
cdesc.target.matrix = hwmatrix;
cdesc.target.rate = sndbuf_getspd(c->bufhard);
cdesc.target.rate = c->bufhard->spd;
} else {
cdesc.origin.afmt = hwfmt;
cdesc.origin.matrix = hwmatrix;
cdesc.origin.rate = sndbuf_getspd(c->bufhard);
cdesc.origin.rate = c->bufhard->spd;
cdesc.target.afmt = softfmt;
cdesc.target.matrix = softmatrix;
cdesc.target.rate = c->speed;

14
sys/dev/sound/pcm/feeder_mixer.c
View file

@ -145,8 +145,8 @@ feed_mixer_rec(struct pcm_channel *c)
b = c->bufsoft;
b->rp = 0;
b->rl = 0;
cnt = sndbuf_getsize(b);
maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(b));
cnt = b->bufsize;
maxfeed = SND_FXROUND(SND_FXDIV_MAX, b->align);
do {
cnt = FEEDER_FEED(c->feeder->source, c, b->tmpbuf,
@ -158,7 +158,7 @@ feed_mixer_rec(struct pcm_channel *c)
} while (cnt != 0);
/* Not enough data */
if (b->rl < sndbuf_getalign(b)) {
if (b->rl < b->align) {
b->rl = 0;
return (0);
}
@ -187,11 +187,11 @@ feed_mixer_rec(struct pcm_channel *c)
if (ch->flags & CHN_F_MMAP)
sndbuf_dispose(bs, NULL, sndbuf_getready(bs));
cnt = sndbuf_getfree(bs);
if (cnt < sndbuf_getalign(bs)) {
if (cnt < bs->align) {
CHN_UNLOCK(ch);
continue;
}
maxfeed = SND_FXROUND(SND_FXDIV_MAX, sndbuf_getalign(bs));
maxfeed = SND_FXROUND(SND_FXDIV_MAX, bs->align);
do {
cnt = FEEDER_FEED(ch->feeder, ch, bs->tmpbuf,
min(cnt, maxfeed), b);
@ -244,7 +244,7 @@ feed_mixer_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
if (c->direction == PCMDIR_REC)
return (feed_mixer_rec(c));
sz = sndbuf_getsize(src);
sz = src->bufsize;
if (sz < count)
count = sz;
@ -260,7 +260,7 @@ feed_mixer_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
* list of children and calling mixer function to mix count bytes from
* each into our destination buffer, b.
*/
tmp = sndbuf_getbuf(src);
tmp = src->buf;
rcnt = 0;
mcnt = 0;
passthrough = 0; /* 'passthrough' / 'exclusive' marker */

55
sys/dev/sound/pcm/sndstat.c
View file

@ -491,29 +491,29 @@ sndstat_build_sound4_nvlist(struct snddev_info *d, nvlist_t **dip)
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_RIGHTVOL,
CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR));
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_FORMAT,
sndbuf_getfmt(c->bufhard));
c->bufhard->fmt);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_RATE,
sndbuf_getspd(c->bufhard));
c->bufhard->spd);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_SIZE,
sndbuf_getsize(c->bufhard));
c->bufhard->bufsize);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_BLKSZ,
sndbuf_getblksz(c->bufhard));
c->bufhard->blksz);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_BLKCNT,
sndbuf_getblkcnt(c->bufhard));
c->bufhard->blkcnt);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_FREE,
sndbuf_getfree(c->bufhard));
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_HWBUF_READY,
sndbuf_getready(c->bufhard));
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_FORMAT,
sndbuf_getfmt(c->bufsoft));
c->bufsoft->fmt);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_RATE,
sndbuf_getspd(c->bufsoft));
c->bufsoft->spd);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_SIZE,
sndbuf_getsize(c->bufsoft));
c->bufsoft->bufsize);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_BLKSZ,
sndbuf_getblksz(c->bufsoft));
c->bufsoft->blksz);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_BLKCNT,
sndbuf_getblkcnt(c->bufsoft));
c->bufsoft->blkcnt);
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_FREE,
sndbuf_getfree(c->bufsoft));
nvlist_add_number(cdi, SNDST_DSPS_SOUND4_CHAN_SWBUF_READY,
@ -1267,14 +1267,11 @@ sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
(c->parentchannel != NULL) ?
c->parentchannel->name : "", c->name);
sbuf_printf(s, "spd %d", c->speed);
if (c->speed != sndbuf_getspd(c->bufhard)) {
sbuf_printf(s, "/%d",
sndbuf_getspd(c->bufhard));
}
if (c->speed != c->bufhard->spd)
sbuf_printf(s, "/%d", c->bufhard->spd);
sbuf_printf(s, ", fmt 0x%08x", c->format);
if (c->format != sndbuf_getfmt(c->bufhard)) {
sbuf_printf(s, "/0x%08x",
sndbuf_getfmt(c->bufhard));
if (c->format != c->bufhard->fmt) {
sbuf_printf(s, "/0x%08x", c->bufhard->fmt);
}
sbuf_printf(s, ", flags 0x%08x, 0x%08x",
c->flags, c->feederflags);
@ -1293,24 +1290,24 @@ sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
c->xruns, c->feedcount,
sndbuf_getfree(c->bufhard),
sndbuf_getfree(c->bufsoft),
sndbuf_getsize(c->bufhard),
sndbuf_getblksz(c->bufhard),
sndbuf_getblkcnt(c->bufhard),
sndbuf_getsize(c->bufsoft),
sndbuf_getblksz(c->bufsoft),
sndbuf_getblkcnt(c->bufsoft));
c->bufhard->bufsize,
c->bufhard->blksz,
c->bufhard->blkcnt,
c->bufsoft->bufsize,
c->bufsoft->blksz,
c->bufsoft->blkcnt);
} else {
sbuf_printf(s,
"underruns %d, feed %u, ready %d "
"\n\t\t[b:%d/%d/%d|bs:%d/%d/%d]",
c->xruns, c->feedcount,
sndbuf_getready(c->bufsoft),
sndbuf_getsize(c->bufhard),
sndbuf_getblksz(c->bufhard),
sndbuf_getblkcnt(c->bufhard),
sndbuf_getsize(c->bufsoft),
sndbuf_getblksz(c->bufsoft),
sndbuf_getblkcnt(c->bufsoft));
c->bufhard->bufsize,
c->bufhard->blksz,
c->bufhard->blkcnt,
c->bufsoft->bufsize,
c->bufsoft->blksz,
c->bufsoft->blkcnt);
}
sbuf_printf(s, "\n\t");

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

@ -492,7 +492,7 @@ sysctl_dev_pcm_vchanrate(SYSCTL_HANDLER_ARGS)
}
}
}
*vchanrate = sndbuf_getspd(c->bufsoft);
*vchanrate = c->bufsoft->spd;
CHN_UNLOCK(c);
}
@ -591,7 +591,7 @@ sysctl_dev_pcm_vchanformat(SYSCTL_HANDLER_ARGS)
}
}
}
*vchanformat = sndbuf_getfmt(c->bufsoft);
*vchanformat = c->bufsoft->fmt;
CHN_UNLOCK(c);
}

4
sys/dev/sound/pcm/vchan.h
View file

@ -48,8 +48,8 @@ int vchan_sync(struct pcm_channel *);
#define VCHAN_SYNC_REQUIRED(c) \
(((c)->flags & CHN_F_VIRTUAL) && (((c)->flags & CHN_F_DIRTY) || \
sndbuf_getfmt((c)->bufhard) != (c)->parentchannel->format || \
sndbuf_getspd((c)->bufhard) != (c)->parentchannel->speed))
(c)->bufhard->fmt != (c)->parentchannel->format || \
(c)->bufhard->spd != (c)->parentchannel->speed))
void vchan_initsys(device_t);