Lines Matching +full:pcm +full:- +full:interface +full:- +full:rate
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2012-2021 Ruslan Bukin <br@bsdpad.com>
5 * Copyright (c) 2023-2024 Florian Walpen <dev@submerge.ch>
31 * RME HDSP driver for FreeBSD (pcm-part).
37 #include <dev/sound/pcm/sound.h>
88 /* ADAT slot bitmap depends on sample rate. */
130 return (slots & (~(slots - 1))); /* Extract first bit set. */
141 return (slots & (ends ^ (ends - 1)));
150 --n;
166 return (hdsp_slot_count(hdsp_slot_first(slots) - 1));
177 preceding = slots & (hdsp_slot_first(subset) - 1);
185 return (ports & (~(ports - 1))); /* Extract first bit set. */
203 return (hc->ports & (HDSP_CHAN_9632_ALL | HDSP_CHAN_9652_ALL));
209 return (hc->ports & (HDSP_CHAN_9632_ALL | HDSP_CHAN_9652_ALL));
221 scp = ch->parent;
222 sc = scp->sc;
227 if (ch->dir != PCMDIR_PLAY)
230 switch (sc->type) {
255 offset -= 1;
273 ports = ch->ports;
285 volume = ch->lvol * HDSP_MAX_GAIN / 100;
294 volume = ch->rvol * HDSP_MAX_GAIN / 100;
312 sc = scp->sc;
314 return (-1);
318 if (hdsp_channel_play_ports(scp->hc))
321 if (hdsp_channel_rec_ports(scp->hc))
324 snd_mtxlock(sc->lock);
325 pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
327 snd_mtxunlock(sc->lock);
343 device_printf(scp->dev, "hdspmixer_set() %d %d\n",
347 for (i = 0; i < scp->chnum; i++) {
348 ch = &scp->chan[i];
349 if ((dev == SOUND_MIXER_VOLUME && ch->dir == PCMDIR_PLAY) ||
350 (dev == SOUND_MIXER_RECLEV && ch->dir == PCMDIR_REC)) {
351 ch->lvol = left;
352 ch->rvol = right;
353 if (ch->run)
377 scp = ch->parent;
378 sc = scp->sc;
380 if (ch->dir == PCMDIR_PLAY)
385 ch->run = value;
388 slots = hdsp_port_slot_map(ch->ports, sc->speed);
415 if (device_get_children(sc->dev, &devlist, &devcount) != 0)
420 for (j = 0; j < scp->chnum; j++) {
421 ch = &scp->chan[j];
422 if (ch->run) {
431 device_printf(sc->dev, "hdsp is running\n");
443 sc->ctrl_register |= (HDSP_AUDIO_INT_ENABLE | HDSP_ENABLE);
444 hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
454 sc->ctrl_register &= ~(HDSP_AUDIO_INT_ENABLE | HDSP_ENABLE);
455 hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
459 buffer_mux_write(uint32_t *dma, uint32_t *pcm, unsigned int pos,
467 pcm[pos * channels + slot];
473 buffer_mux_port(uint32_t *dma, uint32_t *pcm, uint32_t subset, uint32_t slots,
485 pcm += chan_pos;
487 /* Only copy channels supported by both hardware and pcm format. */
492 buffer_mux_write(dma, pcm, pos, pos + samples, 1, channels);
494 buffer_mux_write(dma, pcm, pos, pos + samples, 2, channels);
496 buffer_mux_write(dma, pcm, pos, pos + samples, 4, channels);
498 buffer_mux_write(dma, pcm, pos, pos + samples, 8, channels);
500 buffer_mux_write(dma, pcm, pos, pos + samples, width, channels);
504 buffer_demux_read(uint32_t *dma, uint32_t *pcm, unsigned int pos,
511 pcm[pos * channels + slot] =
518 buffer_demux_port(uint32_t *dma, uint32_t *pcm, uint32_t subset, uint32_t slots,
530 pcm += chan_pos;
532 /* Only copy channels supported by both hardware and pcm format. */
537 buffer_demux_read(dma, pcm, pos, pos + samples, 1, channels);
539 buffer_demux_read(dma, pcm, pos, pos + samples, 2, channels);
541 buffer_demux_read(dma, pcm, pos, pos + samples, 4, channels);
543 buffer_demux_read(dma, pcm, pos, pos + samples, 8, channels);
545 buffer_demux_read(dma, pcm, pos, pos + samples, width, channels);
549 /* Copy data between DMA and PCM buffers. */
560 scp = ch->parent;
561 sc = scp->sc;
563 channels = AFMT_CHANNEL(ch->format); /* Number of PCM channels. */
566 buffer_size = 2 * sc->period * sizeof(uint32_t);
569 if (ch->dir == PCMDIR_PLAY) {
571 pos = sndbuf_getreadyptr(ch->buffer) / channels;
572 length = sndbuf_getready(ch->buffer) / channels;
577 offset = (ch->position + buffer_size) - pos;
581 length -= offset;
585 pos = sndbuf_getfreeptr(ch->buffer) / channels;
591 length = (dma_pos + buffer_size) - pos;
603 remainder = (pos + length) - buffer_size;
606 slots = hdsp_port_slot_map(ch->ports, sc->speed);
611 if (ch->dir == PCMDIR_PLAY) {
612 buffer_mux_port(sc->pbuf, ch->data, row, slots, pos,
613 length - remainder, channels);
614 buffer_mux_port(sc->pbuf, ch->data, row, slots, 0,
617 buffer_demux_port(sc->rbuf, ch->data, row, slots, pos,
618 length - remainder, channels);
619 buffer_demux_port(sc->rbuf, ch->data, row, slots, 0,
627 ch->position = ((pos + length) * 4) % buffer_size;
639 scp = ch->parent;
640 sc = scp->sc;
641 buf = sc->rbuf;
643 if (ch->dir == PCMDIR_PLAY)
644 buf = sc->pbuf;
647 slots = hdsp_port_slot_map(ch->ports, sc->speed);
658 ch->position = 0;
663 /* Channel interface. */
672 scp = ch->parent;
673 sc = scp->sc;
676 device_printf(scp->dev, "hdspchan_free()\n");
679 snd_mtxlock(sc->lock);
680 if (ch->data != NULL) {
681 free(ch->data, M_HDSP);
682 ch->data = NULL;
684 if (ch->caps != NULL) {
685 free(ch->caps, M_HDSP);
686 ch->caps = NULL;
688 snd_mtxunlock(sc->lock);
703 sc = scp->sc;
705 snd_mtxlock(sc->lock);
706 num = scp->chnum;
708 ch = &scp->chan[num];
711 ch->ports = hdsp_channel_play_ports(scp->hc);
713 ch->ports = hdsp_channel_rec_ports(scp->hc);
715 ch->run = 0;
716 ch->lvol = 0;
717 ch->rvol = 0;
720 ch->cap_fmts[0] =
721 SND_FORMAT(AFMT_S32_LE, hdsp_port_slot_count(ch->ports, 48000), 0);
722 ch->cap_fmts[1] =
723 SND_FORMAT(AFMT_S32_LE, hdsp_port_slot_count(ch->ports, 96000), 0);
724 ch->cap_fmts[2] =
725 SND_FORMAT(AFMT_S32_LE, hdsp_port_slot_count(ch->ports, 192000), 0);
726 ch->cap_fmts[3] = 0;
728 ch->caps = malloc(sizeof(struct pcmchan_caps), M_HDSP, M_NOWAIT);
729 *(ch->caps) = (struct pcmchan_caps) {32000, 192000, ch->cap_fmts, 0};
732 if (sc->type == HDSP_9652) {
733 ch->cap_fmts[2] = SND_FORMAT(AFMT_S32_LE, 2, 0);
734 ch->caps->maxspeed = 96000;
738 ch->size = HDSP_CHANBUF_SIZE * hdsp_port_slot_count_max(ch->ports);
739 ch->data = malloc(ch->size, M_HDSP, M_NOWAIT);
740 ch->position = 0;
742 ch->buffer = b;
743 ch->channel = c;
744 ch->parent = scp;
746 ch->dir = dir;
748 snd_mtxunlock(sc->lock);
750 if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
751 device_printf(scp->dev, "Can't setup sndbuf.\n");
767 scp = ch->parent;
768 sc = scp->sc;
770 snd_mtxlock(sc->lock);
774 device_printf(scp->dev, "hdspchan_trigger(): start\n");
784 device_printf(scp->dev, "hdspchan_trigger(): stop or abort\n");
793 if(ch->run)
798 snd_mtxunlock(sc->lock);
812 scp = ch->parent;
813 sc = scp->sc;
815 snd_mtxlock(sc->lock);
817 snd_mtxunlock(sc->lock);
820 pos %= (2 * sc->period * sizeof(uint32_t)); /* Double buffer. */
821 pos *= AFMT_CHANNEL(ch->format); /* Hardbuf with multiple channels. */
834 struct sc_pcminfo *scp = ch->parent;
835 device_printf(scp->dev, "hdspchan_setformat(%d)\n", format);
838 ch->format = format;
854 scp = ch->parent;
855 sc = scp->sc;
859 device_printf(scp->dev, "hdspchan_setspeed(%d)\n", speed);
866 if (sc->type == HDSP_9652 && speed > 96000)
869 if (sc->force_speed > 0)
870 speed = sc->force_speed;
882 threshold = hr->speed + ((rate_map[i + 1].speed != 0) ?
883 ((rate_map[i + 1].speed - hr->speed) >> 1) : 0);
890 sc->ctrl_register &= ~HDSP_FREQ_MASK;
891 sc->ctrl_register |= hr->reg;
892 hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
894 if (sc->type == HDSP_9632) {
896 hdsp_write_4(sc, HDSP_FREQ_REG, hdsp_freq_reg_value(hr->speed));
899 sc->speed = hr->speed;
902 return (sc->speed);
916 scp = ch->parent;
917 sc = scp->sc;
921 device_printf(scp->dev, "hdspchan_setblocksize(%d)\n", blocksize);
934 if (sc->force_period > 0)
935 blocksize = sc->force_period;
947 threshold = hl->period + ((latency_map[i + 1].period != 0) ?
948 ((latency_map[i + 1].period - hl->period) >> 1) : 0);
954 snd_mtxlock(sc->lock);
955 sc->ctrl_register &= ~HDSP_LAT_MASK;
956 sc->ctrl_register |= hdsp_encode_latency(hl->n);
957 hdsp_write_4(sc, HDSP_CONTROL_REG, sc->ctrl_register);
958 sc->period = hl->period;
959 snd_mtxunlock(sc->lock);
962 device_printf(scp->dev, "New period=%d\n", sc->period);
965 sndbuf_resize(ch->buffer, 2,
966 (sc->period * AFMT_CHANNEL(ch->format) * sizeof(uint32_t)));
970 if (sc->type == HDSP_9632)
971 hdsp_write_4(sc, HDSP_FREQ_REG, hdsp_freq_reg_value(sc->speed));
974 return (sndbuf_getblksz(ch->buffer));
993 device_printf(ch->parent->dev, "hdspchan_getcaps()\n");
996 if (ch->caps != NULL)
997 return (ch->caps);
1033 sc = scp->sc;
1035 for (i = 0; i < scp->chnum; i++) {
1036 ch = &scp->chan[i];
1037 snd_mtxunlock(sc->lock);
1038 chn_intr(ch->channel);
1039 snd_mtxlock(sc->lock);
1056 scp->ih = &hdsp_pcm_intr;
1058 if (scp->hc->ports & HDSP_CHAN_9632_ALL)
1060 else if (scp->hc->ports & HDSP_CHAN_9652_ALL)
1064 device_set_descf(dev, "HDSP %s [%s]", buf, scp->hc->descr);
1068 * in pcm device. Mark pcm device as MPSAFE manually.
1071 if (hdsp_port_slot_count_max(scp->hc->ports) > HDSP_MATRIX_MAX)
1078 play = (hdsp_channel_play_ports(scp->hc)) ? 1 : 0;
1079 rec = (hdsp_channel_rec_ports(scp->hc)) ? 1 : 0;
1081 scp->chnum = 0;
1084 scp->chnum++;
1089 scp->chnum++;
1093 rman_get_start(scp->sc->cs),
1094 rman_get_start(scp->sc->irq),
1098 device_printf(dev, "Can't register pcm.\n");
1129 "pcm",