2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2012-2016 Ruslan Bukin <br@bsdpad.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * RME HDSPe driver for FreeBSD (pcm-part).
31 * Supported cards: AIO, RayDAT.
34 #include <dev/sound/pcm/sound.h>
35 #include <dev/sound/pci/hdspe.h>
36 #include <dev/sound/chip.h>
38 #include <dev/pci/pcireg.h>
39 #include <dev/pci/pcivar.h>
43 SND_DECLARE_FILE("$FreeBSD$");
45 struct hdspe_latency {
51 static struct hdspe_latency latency_map[] = {
69 static struct hdspe_rate rate_map[] = {
70 { 32000, (HDSPE_FREQ_32000) },
71 { 44100, (HDSPE_FREQ_44100) },
72 { 48000, (HDSPE_FREQ_48000) },
73 { 64000, (HDSPE_FREQ_32000 | HDSPE_FREQ_DOUBLE) },
74 { 88200, (HDSPE_FREQ_44100 | HDSPE_FREQ_DOUBLE) },
75 { 96000, (HDSPE_FREQ_48000 | HDSPE_FREQ_DOUBLE) },
76 { 128000, (HDSPE_FREQ_32000 | HDSPE_FREQ_QUAD) },
77 { 176400, (HDSPE_FREQ_44100 | HDSPE_FREQ_QUAD) },
78 { 192000, (HDSPE_FREQ_48000 | HDSPE_FREQ_QUAD) },
85 hdspe_hw_mixer(struct sc_chinfo *ch, unsigned int dst,
86 unsigned int src, unsigned short data)
88 struct sc_pcminfo *scp;
96 if (ch->dir == PCMDIR_PLAY)
99 hdspe_write_4(sc, HDSPE_MIXER_BASE +
100 ((offs + src + 128 * dst) * sizeof(uint32_t)),
107 hdspechan_setgain(struct sc_chinfo *ch)
110 hdspe_hw_mixer(ch, ch->lslot, ch->lslot,
111 ch->lvol * HDSPE_MAX_GAIN / 100);
112 hdspe_hw_mixer(ch, ch->rslot, ch->rslot,
113 ch->rvol * HDSPE_MAX_GAIN / 100);
119 hdspemixer_init(struct snd_mixer *m)
121 struct sc_pcminfo *scp;
125 scp = mix_getdevinfo(m);
130 mask = SOUND_MASK_PCM;
133 mask |= SOUND_MASK_VOLUME;
136 mask |= SOUND_MASK_RECLEV;
138 snd_mtxlock(sc->lock);
139 pcm_setflags(scp->dev, pcm_getflags(scp->dev) | SD_F_SOFTPCMVOL);
140 mix_setdevs(m, mask);
141 snd_mtxunlock(sc->lock);
147 hdspemixer_set(struct snd_mixer *m, unsigned dev,
148 unsigned left, unsigned right)
150 struct sc_pcminfo *scp;
151 struct sc_chinfo *ch;
154 scp = mix_getdevinfo(m);
157 device_printf(scp->dev, "hdspemixer_set() %d %d\n",
161 for (i = 0; i < scp->chnum; i++) {
163 if ((dev == SOUND_MIXER_VOLUME && ch->dir == PCMDIR_PLAY) ||
164 (dev == SOUND_MIXER_RECLEV && ch->dir == PCMDIR_REC)) {
168 hdspechan_setgain(ch);
175 static kobj_method_t hdspemixer_methods[] = {
176 KOBJMETHOD(mixer_init, hdspemixer_init),
177 KOBJMETHOD(mixer_set, hdspemixer_set),
180 MIXER_DECLARE(hdspemixer);
183 hdspechan_enable(struct sc_chinfo *ch, int value)
185 struct sc_pcminfo *scp;
192 if (ch->dir == PCMDIR_PLAY)
193 reg = HDSPE_OUT_ENABLE_BASE;
195 reg = HDSPE_IN_ENABLE_BASE;
199 hdspe_write_1(sc, reg + (4 * ch->lslot), value);
200 hdspe_write_1(sc, reg + (4 * ch->rslot), value);
204 hdspe_running(struct sc_info *sc)
206 struct sc_pcminfo *scp;
207 struct sc_chinfo *ch;
213 if ((err = device_get_children(sc->dev, &devlist, &devcount)) != 0)
216 for (i = 0; i < devcount; i++) {
217 scp = device_get_ivars(devlist[i]);
218 for (j = 0; j < scp->chnum; j++) {
225 free(devlist, M_TEMP);
231 device_printf(sc->dev, "hdspe is running\n");
234 free(devlist, M_TEMP);
240 hdspe_start_audio(struct sc_info *sc)
243 sc->ctrl_register |= (HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
244 hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
248 hdspe_stop_audio(struct sc_info *sc)
251 if (hdspe_running(sc) == 1)
254 sc->ctrl_register &= ~(HDSPE_AUDIO_INT_ENABLE | HDSPE_ENABLE);
255 hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
258 /* Multiplex / demultiplex: 2.0 <-> 2 x 1.0. */
260 buffer_copy(struct sc_chinfo *ch)
262 struct sc_pcminfo *scp;
272 length = sndbuf_getready(ch->buffer) /
273 (4 /* Bytes per sample. */ * 2 /* channels */);
275 if (ch->dir == PCMDIR_PLAY) {
276 src = sndbuf_getreadyptr(ch->buffer);
278 src = sndbuf_getfreeptr(ch->buffer);
281 src /= 4; /* Bytes per sample. */
282 dst = src / 2; /* Destination buffer twice smaller. */
284 ssize = ch->size / 4;
285 dsize = ch->size / 8;
288 * Use two fragment buffer to avoid sound clipping.
291 for (i = 0; i < sc->period * 2 /* fragments */; i++) {
292 if (ch->dir == PCMDIR_PLAY) {
293 sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot] =
295 sc->pbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot] =
300 sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->lslot];
302 sc->rbuf[dst + HDSPE_CHANBUF_SAMPLES * ch->rslot];
313 clean(struct sc_chinfo *ch)
315 struct sc_pcminfo *scp;
323 if (ch->dir == PCMDIR_PLAY) {
327 bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->lslot, HDSPE_CHANBUF_SIZE);
328 bzero(buf + HDSPE_CHANBUF_SAMPLES * ch->rslot, HDSPE_CHANBUF_SIZE);
334 /* Channel interface. */
336 hdspechan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
337 struct pcm_channel *c, int dir)
339 struct sc_pcminfo *scp;
340 struct sc_chinfo *ch;
347 snd_mtxlock(sc->lock);
350 ch = &scp->chan[num];
351 ch->lslot = scp->hc->left;
352 ch->rslot = scp->hc->right;
357 ch->size = HDSPE_CHANBUF_SIZE * 2 /* slots */;
358 ch->data = malloc(ch->size, M_HDSPE, M_NOWAIT);
366 snd_mtxunlock(sc->lock);
368 if (sndbuf_setup(ch->buffer, ch->data, ch->size) != 0) {
369 device_printf(scp->dev, "Can't setup sndbuf.\n");
377 hdspechan_trigger(kobj_t obj, void *data, int go)
379 struct sc_pcminfo *scp;
380 struct sc_chinfo *ch;
387 snd_mtxlock(sc->lock);
391 device_printf(scp->dev, "hdspechan_trigger(): start\n");
393 hdspechan_enable(ch, 1);
394 hdspechan_setgain(ch);
395 hdspe_start_audio(sc);
401 device_printf(scp->dev, "hdspechan_trigger(): stop or abort\n");
404 hdspechan_enable(ch, 0);
405 hdspe_stop_audio(sc);
408 case PCMTRIG_EMLDMAWR:
409 case PCMTRIG_EMLDMARD:
415 snd_mtxunlock(sc->lock);
421 hdspechan_getptr(kobj_t obj, void *data)
423 struct sc_pcminfo *scp;
424 struct sc_chinfo *ch;
432 snd_mtxlock(sc->lock);
433 ret = hdspe_read_2(sc, HDSPE_STATUS_REG);
434 snd_mtxunlock(sc->lock);
436 pos = ret & HDSPE_BUF_POSITION_MASK;
437 pos *= 2; /* Hardbuf twice bigger. */
443 hdspechan_free(kobj_t obj, void *data)
445 struct sc_pcminfo *scp;
446 struct sc_chinfo *ch;
454 device_printf(scp->dev, "hdspechan_free()\n");
457 snd_mtxlock(sc->lock);
458 if (ch->data != NULL) {
459 free(ch->data, M_HDSPE);
462 snd_mtxunlock(sc->lock);
468 hdspechan_setformat(kobj_t obj, void *data, uint32_t format)
470 struct sc_chinfo *ch;
475 struct sc_pcminfo *scp = ch->parent;
476 device_printf(scp->dev, "hdspechan_setformat(%d)\n", format);
485 hdspechan_setspeed(kobj_t obj, void *data, uint32_t speed)
487 struct sc_pcminfo *scp;
488 struct hdspe_rate *hr;
489 struct sc_chinfo *ch;
501 device_printf(scp->dev, "hdspechan_setspeed(%d)\n", speed);
504 if (hdspe_running(sc) == 1)
507 /* First look for equal frequency. */
508 for (i = 0; rate_map[i].speed != 0; i++) {
509 if (rate_map[i].speed == speed)
513 /* If no match, just find nearest. */
515 for (i = 0; rate_map[i].speed != 0; i++) {
517 threshold = hr->speed + ((rate_map[i + 1].speed != 0) ?
518 ((rate_map[i + 1].speed - hr->speed) >> 1) : 0);
519 if (speed < threshold)
527 period = HDSPE_FREQ_AIO;
530 /* Unsupported card. */
534 /* Write frequency on the device. */
535 sc->ctrl_register &= ~HDSPE_FREQ_MASK;
536 sc->ctrl_register |= hr->reg;
537 hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
542 else if (speed > 48000)
547 hdspe_write_4(sc, HDSPE_FREQ_REG, period);
549 sc->speed = hr->speed;
556 hdspechan_setblocksize(kobj_t obj, void *data, uint32_t blocksize)
558 struct hdspe_latency *hl;
559 struct sc_pcminfo *scp;
560 struct sc_chinfo *ch;
571 device_printf(scp->dev, "hdspechan_setblocksize(%d)\n", blocksize);
574 if (hdspe_running(sc) == 1)
577 if (blocksize > HDSPE_LAT_BYTES_MAX)
578 blocksize = HDSPE_LAT_BYTES_MAX;
579 else if (blocksize < HDSPE_LAT_BYTES_MIN)
580 blocksize = HDSPE_LAT_BYTES_MIN;
582 blocksize /= 4 /* samples */;
584 /* First look for equal latency. */
585 for (i = 0; latency_map[i].period != 0; i++) {
586 if (latency_map[i].period == blocksize) {
587 hl = &latency_map[i];
591 /* If no match, just find nearest. */
593 for (i = 0; latency_map[i].period != 0; i++) {
594 hl = &latency_map[i];
595 threshold = hl->period + ((latency_map[i + 1].period != 0) ?
596 ((latency_map[i + 1].period - hl->period) >> 1) : 0);
597 if (blocksize < threshold)
602 snd_mtxlock(sc->lock);
603 sc->ctrl_register &= ~HDSPE_LAT_MASK;
604 sc->ctrl_register |= hdspe_encode_latency(hl->n);
605 hdspe_write_4(sc, HDSPE_CONTROL_REG, sc->ctrl_register);
606 sc->period = hl->period;
607 snd_mtxunlock(sc->lock);
610 device_printf(scp->dev, "New period=%d\n", sc->period);
613 sndbuf_resize(ch->buffer, (HDSPE_CHANBUF_SIZE * 2) / (sc->period * 4),
617 return (sndbuf_getblksz(ch->buffer));
620 static uint32_t hdspe_rfmt[] = {
621 SND_FORMAT(AFMT_S32_LE, 2, 0),
625 static struct pcmchan_caps hdspe_rcaps = {32000, 192000, hdspe_rfmt, 0};
627 static uint32_t hdspe_pfmt[] = {
628 SND_FORMAT(AFMT_S32_LE, 2, 0),
632 static struct pcmchan_caps hdspe_pcaps = {32000, 192000, hdspe_pfmt, 0};
634 static struct pcmchan_caps *
635 hdspechan_getcaps(kobj_t obj, void *data)
637 struct sc_chinfo *ch;
642 struct sc_pcminfo *scl = ch->parent;
643 device_printf(scp->dev, "hdspechan_getcaps()\n");
646 return ((ch->dir == PCMDIR_PLAY) ?
647 &hdspe_pcaps : &hdspe_rcaps);
650 static kobj_method_t hdspechan_methods[] = {
651 KOBJMETHOD(channel_init, hdspechan_init),
652 KOBJMETHOD(channel_free, hdspechan_free),
653 KOBJMETHOD(channel_setformat, hdspechan_setformat),
654 KOBJMETHOD(channel_setspeed, hdspechan_setspeed),
655 KOBJMETHOD(channel_setblocksize, hdspechan_setblocksize),
656 KOBJMETHOD(channel_trigger, hdspechan_trigger),
657 KOBJMETHOD(channel_getptr, hdspechan_getptr),
658 KOBJMETHOD(channel_getcaps, hdspechan_getcaps),
661 CHANNEL_DECLARE(hdspechan);
665 hdspe_pcm_probe(device_t dev)
669 device_printf(dev,"hdspe_pcm_probe()\n");
676 hdspe_pcm_intr(struct sc_pcminfo *scp)
678 struct sc_chinfo *ch;
684 for (i = 0; i < scp->chnum; i++) {
686 snd_mtxunlock(sc->lock);
687 chn_intr(ch->channel);
688 snd_mtxlock(sc->lock);
695 hdspe_pcm_attach(device_t dev)
697 char status[SND_STATUSLEN];
698 struct sc_pcminfo *scp;
702 scp = device_get_ivars(dev);
703 scp->ih = &hdspe_pcm_intr;
705 bzero(desc, sizeof(desc));
706 snprintf(desc, sizeof(desc), "HDSPe AIO [%s]", scp->hc->descr);
707 device_set_desc_copy(dev, desc);
710 * We don't register interrupt handler with snd_setup_intr
711 * in pcm device. Mark pcm device as MPSAFE manually.
713 pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);
715 err = pcm_register(dev, scp, scp->hc->play, scp->hc->rec);
717 device_printf(dev, "Can't register pcm.\n");
722 for (i = 0; i < scp->hc->play; i++) {
723 pcm_addchan(dev, PCMDIR_PLAY, &hdspechan_class, scp);
727 for (i = 0; i < scp->hc->rec; i++) {
728 pcm_addchan(dev, PCMDIR_REC, &hdspechan_class, scp);
732 snprintf(status, SND_STATUSLEN, "at io 0x%jx irq %jd %s",
733 rman_get_start(scp->sc->cs),
734 rman_get_start(scp->sc->irq),
735 PCM_KLDSTRING(snd_hdspe));
736 pcm_setstatus(dev, status);
738 mixer_init(dev, &hdspemixer_class, scp);
744 hdspe_pcm_detach(device_t dev)
748 err = pcm_unregister(dev);
750 device_printf(dev, "Can't unregister device.\n");
757 static device_method_t hdspe_pcm_methods[] = {
758 DEVMETHOD(device_probe, hdspe_pcm_probe),
759 DEVMETHOD(device_attach, hdspe_pcm_attach),
760 DEVMETHOD(device_detach, hdspe_pcm_detach),
764 static driver_t hdspe_pcm_driver = {
770 DRIVER_MODULE(snd_hdspe_pcm, hdspe, hdspe_pcm_driver, pcm_devclass, 0, 0);
771 MODULE_DEPEND(snd_hdspe, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
772 MODULE_VERSION(snd_hdspe, 1);