2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
3 * (C) 1997 Luigi Rizzo (luigi@iet.unipi.it)
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * $FreeBSD: src/sys/dev/sound/pcm/sound.c,v 1.17.2.14 2002/11/07 23:17:18 cognet Exp $
28 * $DragonFly: src/sys/dev/sound/pcm/sound.c,v 1.3 2003/11/15 21:05:42 dillon Exp $
31 #include <dev/sound/pcm/sound.h>
32 #include <dev/sound/pcm/vchan.h>
33 #include <sys/sysctl.h>
35 #include "feeder_if.h"
37 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/sound.c,v 1.3 2003/11/15 21:05:42 dillon Exp $");
39 struct snddev_channel {
40 SLIST_ENTRY(snddev_channel) link;
41 struct pcm_channel *channel;
45 SLIST_HEAD(, snddev_channel) channels;
46 struct pcm_channel *fakechan;
47 unsigned devcount, playcount, reccount, vchancount;
53 char status[SND_STATUSLEN];
54 struct sysctl_ctx_list sysctl_tree;
55 struct sysctl_oid *sysctl_tree_top;
59 devclass_t pcm_devclass;
61 int pcm_veto_load = 1;
65 TUNABLE_INT("hw.snd.unit", &snd_unit);
68 int snd_maxautovchans = 0;
69 TUNABLE_INT("hw.snd.maxautovchans", &snd_maxautovchans);
71 SYSCTL_NODE(_hw, OID_AUTO, snd, CTLFLAG_RD, 0, "Sound driver");
73 static int sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose);
75 struct sysctl_ctx_list *
76 snd_sysctl_tree(device_t dev)
78 struct snddev_info *d = device_get_softc(dev);
80 return &d->sysctl_tree;
84 snd_sysctl_tree_top(device_t dev)
86 struct snddev_info *d = device_get_softc(dev);
88 return d->sysctl_tree_top;
92 snd_mtxcreate(const char *desc, const char *type)
97 m = malloc(sizeof(*m), M_DEVBUF, M_WAITOK | M_ZERO);
100 mtx_init(m, desc, type, MTX_RECURSE);
103 return (void *)0xcafebabe;
113 mtx_assert(mtx, MA_OWNED);
120 snd_mtxassert(void *m)
126 mtx_assert(mtx, MA_OWNED);
142 snd_mtxunlock(void *m)
152 snd_setup_intr(device_t dev, struct resource *res, int flags, driver_intr_t hand, void *param, void **cookiep)
155 flags &= INTR_MPSAFE;
156 flags |= INTR_TYPE_AV;
158 flags = INTR_TYPE_AV;
160 return bus_setup_intr(dev, res, flags, hand, param, cookiep);
164 pcm_lock(struct snddev_info *d)
166 snd_mtxlock(d->lock);
170 pcm_unlock(struct snddev_info *d)
172 snd_mtxunlock(d->lock);
176 pcm_getfakechan(struct snddev_info *d)
181 /* return a locked channel */
183 pcm_chnalloc(struct snddev_info *d, int direction, pid_t pid, int chnum)
185 struct pcm_channel *c;
186 struct snddev_channel *sce;
189 snd_mtxassert(d->lock);
191 /* scan for a free channel */
192 SLIST_FOREACH(sce, &d->channels, link) {
195 if ((c->direction == direction) && !(c->flags & CHN_F_BUSY)) {
196 if (chnum == -1 || c->num == chnum) {
197 c->flags |= CHN_F_BUSY;
205 /* no channel available */
206 if (direction == PCMDIR_PLAY) {
207 if ((d->vchancount > 0) && (d->vchancount < snd_maxautovchans)) {
208 /* try to create a vchan */
209 SLIST_FOREACH(sce, &d->channels, link) {
211 if (!SLIST_EMPTY(&c->children)) {
212 err = vchan_create(c);
214 return pcm_chnalloc(d, direction, pid, -1);
216 device_printf(d->dev, "vchan_create(%s) == %d\n", c->name, err);
225 /* release a locked channel and unlock it */
227 pcm_chnrelease(struct pcm_channel *c)
230 c->flags &= ~CHN_F_BUSY;
237 pcm_chnref(struct pcm_channel *c, int ref)
248 pcm_inprog(struct snddev_info *d, int delta)
255 pcm_setmaxautovchans(struct snddev_info *d, int num)
257 struct pcm_channel *c;
258 struct snddev_channel *sce;
261 if (num > 0 && d->vchancount == 0) {
262 SLIST_FOREACH(sce, &d->channels, link) {
264 if ((c->direction == PCMDIR_PLAY) && !(c->flags & CHN_F_BUSY)) {
265 c->flags |= CHN_F_BUSY;
266 err = vchan_create(c);
268 device_printf(d->dev, "vchan_create(%s) == %d\n", c->name, err);
269 c->flags &= ~CHN_F_BUSY;
275 if (num == 0 && d->vchancount > 0) {
279 SLIST_FOREACH(sce, &d->channels, link) {
281 if ((c->flags & CHN_F_VIRTUAL) && !(c->flags & CHN_F_BUSY)) {
283 err = vchan_destroy(c);
285 device_printf(d->dev, "vchan_destroy(%s) == %d\n", c->name, err);
295 sysctl_hw_snd_unit(SYSCTL_HANDLER_ARGS)
297 struct snddev_info *d;
301 error = sysctl_handle_int(oidp, &unit, sizeof(unit), req);
302 if (error == 0 && req->newptr != NULL) {
303 if (unit < 0 || unit >= devclass_get_maxunit(pcm_devclass))
305 d = devclass_get_softc(pcm_devclass, unit);
306 if (d == NULL || SLIST_EMPTY(&d->channels))
312 SYSCTL_PROC(_hw_snd, OID_AUTO, unit, CTLTYPE_INT | CTLFLAG_RW,
313 0, sizeof(int), sysctl_hw_snd_unit, "I", "");
317 sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
319 struct snddev_info *d;
322 v = snd_maxautovchans;
323 error = sysctl_handle_int(oidp, &v, sizeof(v), req);
324 if (error == 0 && req->newptr != NULL) {
325 if (v < 0 || v >= SND_MAXVCHANS)
327 if (v != snd_maxautovchans) {
328 for (i = 0; i < devclass_get_maxunit(pcm_devclass); i++) {
329 d = devclass_get_softc(pcm_devclass, i);
332 pcm_setmaxautovchans(d, v);
335 snd_maxautovchans = v;
339 SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans, CTLTYPE_INT | CTLFLAG_RW,
340 0, sizeof(int), sysctl_hw_snd_maxautovchans, "I", "");
343 pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, void *devinfo)
345 struct pcm_channel *ch;
352 pnum = &d->playcount;
363 pnum = &d->vchancount;
370 ch = malloc(sizeof(*ch), M_DEVBUF, M_WAITOK | M_ZERO);
374 ch->methods = kobj_create(cls, M_DEVBUF, M_WAITOK);
384 ch->parentsnddev = d;
385 ch->parentchannel = parent;
387 snprintf(ch->name, 32, "%s:%s:%d", device_get_nameunit(d->dev), dirs, ch->num);
389 err = chn_init(ch, devinfo, dir);
391 device_printf(d->dev, "chn_init(%s) failed: err = %d\n", ch->name, err);
392 kobj_delete(ch->methods, M_DEVBUF);
403 pcm_chn_destroy(struct pcm_channel *ch)
405 struct snddev_info *d;
408 d = ch->parentsnddev;
411 device_printf(d->dev, "chn_kill(%s) failed, err = %d\n", ch->name, err);
415 if (ch->direction == PCMDIR_REC)
417 else if (ch->flags & CHN_F_VIRTUAL)
422 kobj_delete(ch->methods, M_DEVBUF);
429 pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch, int mkdev)
431 struct snddev_channel *sce, *tmp, *after;
432 int unit = device_get_unit(d->dev);
434 snd_mtxlock(d->lock);
436 sce = malloc(sizeof(*sce), M_DEVBUF, M_WAITOK | M_ZERO);
438 snd_mtxunlock(d->lock);
443 if (SLIST_EMPTY(&d->channels)) {
444 SLIST_INSERT_HEAD(&d->channels, sce, link);
447 SLIST_FOREACH(tmp, &d->channels, link) {
450 SLIST_INSERT_AFTER(after, sce, link);
454 dsp_register(unit, d->devcount++);
455 if (ch->direction == PCMDIR_REC)
456 dsp_registerrec(unit, ch->num);
459 snd_mtxunlock(d->lock);
465 pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch, int rmdev)
467 struct snddev_channel *sce;
468 int unit = device_get_unit(d->dev);
470 snd_mtxlock(d->lock);
471 SLIST_FOREACH(sce, &d->channels, link) {
472 if (sce->channel == ch)
475 snd_mtxunlock(d->lock);
478 SLIST_REMOVE(&d->channels, sce, snddev_channel, link);
482 dsp_unregister(unit, --d->devcount);
483 if (ch->direction == PCMDIR_REC)
484 dsp_unregisterrec(unit, ch->num);
486 snd_mtxunlock(d->lock);
492 pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
494 struct snddev_info *d = device_get_softc(dev);
495 struct pcm_channel *ch;
498 ch = pcm_chn_create(d, NULL, cls, dir, devinfo);
500 device_printf(d->dev, "pcm_chn_create(%s, %d, %p) failed\n", cls->name, dir, devinfo);
504 err = pcm_chn_add(d, ch, 1);
506 device_printf(d->dev, "pcm_chn_add(%s) failed, err=%d\n", ch->name, err);
511 if (snd_maxautovchans > 0 && (d->flags & SD_F_AUTOVCHAN)) {
512 ch->flags |= CHN_F_BUSY;
513 err = vchan_create(ch);
515 device_printf(d->dev, "vchan_create(%s) == %d\n", ch->name, err);
516 ch->flags &= ~CHN_F_BUSY;
524 pcm_killchan(device_t dev)
526 struct snddev_info *d = device_get_softc(dev);
527 struct snddev_channel *sce;
528 struct pcm_channel *ch;
531 snd_mtxlock(d->lock);
532 sce = SLIST_FIRST(&d->channels);
533 snd_mtxunlock(d->lock);
536 error = pcm_chn_remove(d, sce->channel, 1);
539 return (pcm_chn_destroy(ch));
543 pcm_setstatus(device_t dev, char *str)
545 struct snddev_info *d = device_get_softc(dev);
547 snd_mtxlock(d->lock);
548 strncpy(d->status, str, SND_STATUSLEN);
549 snd_mtxunlock(d->lock);
554 pcm_getflags(device_t dev)
556 struct snddev_info *d = device_get_softc(dev);
562 pcm_setflags(device_t dev, u_int32_t val)
564 struct snddev_info *d = device_get_softc(dev);
570 pcm_getdevinfo(device_t dev)
572 struct snddev_info *d = device_get_softc(dev);
578 pcm_getbuffersize(device_t dev, unsigned int min, unsigned int deflt, unsigned int max)
580 struct snddev_info *d = device_get_softc(dev);
584 if (resource_int_value(device_get_name(dev), device_get_unit(dev), "buffersize", &sz) == 0) {
588 device_printf(dev, "'buffersize=%d' hint is out of range (%d-%d), using %d\n", x, min, max, sz);
595 device_printf(dev, "'buffersize=%d' hint is not a power of 2, using %d\n", sz, x);
608 pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
610 struct snddev_info *d = device_get_softc(dev);
613 device_printf(dev, "disabled due to an error while initialising: %d\n", pcm_veto_load);
618 d->lock = snd_mtxcreate(device_get_nameunit(dev), "sound cdev");
619 snd_mtxlock(d->lock);
623 d->devinfo = devinfo;
630 if (((numplay == 0) || (numrec == 0)) && (numplay != numrec))
631 d->flags |= SD_F_SIMPLEX;
633 d->fakechan = fkchan_setup(dev);
634 chn_init(d->fakechan, NULL, 0);
637 sysctl_ctx_init(&d->sysctl_tree);
638 d->sysctl_tree_top = SYSCTL_ADD_NODE(&d->sysctl_tree,
639 SYSCTL_STATIC_CHILDREN(_hw_snd), OID_AUTO,
640 device_get_nameunit(dev), CTLFLAG_RD, 0, "");
641 if (d->sysctl_tree_top == NULL) {
642 sysctl_ctx_free(&d->sysctl_tree);
645 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
646 OID_AUTO, "buffersize", CTLFLAG_RD, &d->bufsz, 0, "");
651 d->flags |= SD_F_AUTOVCHAN;
653 snd_mtxunlock(d->lock);
654 sndstat_register(dev, d->status, sndstat_prepare_pcm);
657 snd_mtxfree(d->lock);
662 pcm_unregister(device_t dev)
664 struct snddev_info *d = device_get_softc(dev);
665 struct snddev_channel *sce;
666 struct pcm_channel *ch;
668 snd_mtxlock(d->lock);
670 device_printf(dev, "unregister: operation in progress\n");
671 snd_mtxunlock(d->lock);
674 if (sndstat_busy() != 0) {
675 device_printf(dev, "unregister: sndstat busy\n");
676 snd_mtxunlock(d->lock);
679 SLIST_FOREACH(sce, &d->channels, link) {
681 if (ch->refcount > 0) {
682 device_printf(dev, "unregister: channel %s busy (pid %d)\n", ch->name, ch->pid);
683 snd_mtxunlock(d->lock);
687 if (mixer_uninit(dev)) {
688 device_printf(dev, "unregister: mixer busy\n");
689 snd_mtxunlock(d->lock);
694 d->sysctl_tree_top = NULL;
695 sysctl_ctx_free(&d->sysctl_tree);
697 while (!SLIST_EMPTY(&d->channels))
700 chn_kill(d->fakechan);
701 fkchan_kill(d->fakechan);
703 snd_mtxfree(d->lock);
707 /************************************************************************/
710 sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
712 struct snddev_info *d;
713 struct snddev_channel *sce;
714 struct pcm_channel *c;
715 struct pcm_feeder *f;
721 d = device_get_softc(dev);
725 snd_mtxlock(d->lock);
726 if (!SLIST_EMPTY(&d->channels)) {
728 SLIST_FOREACH(sce, &d->channels, link) {
730 if (c->direction == PCMDIR_PLAY) {
731 if (c->flags & CHN_F_VIRTUAL)
738 sbuf_printf(s, " (%dp/%dr/%dv channels%s%s)", d->playcount, d->reccount, d->vchancount,
739 (d->flags & SD_F_SIMPLEX)? "" : " duplex",
741 (device_get_unit(dev) == snd_unit)? " default" : ""
748 SLIST_FOREACH(sce, &d->channels, link) {
750 sbuf_printf(s, "\n\t");
752 sbuf_printf(s, "%s[%s]: ", c->parentchannel? c->parentchannel->name : "", c->name);
753 sbuf_printf(s, "spd %d", c->speed);
754 if (c->speed != sndbuf_getspd(c->bufhard))
755 sbuf_printf(s, "/%d", sndbuf_getspd(c->bufhard));
756 sbuf_printf(s, ", fmt 0x%08x", c->format);
757 if (c->format != sndbuf_getfmt(c->bufhard))
758 sbuf_printf(s, "/0x%08x", sndbuf_getfmt(c->bufhard));
759 sbuf_printf(s, ", flags %08x", c->flags);
761 sbuf_printf(s, ", pid %d", c->pid);
762 sbuf_printf(s, "\n\t");
764 if (c->bufhard != NULL && c->bufsoft != NULL) {
765 sbuf_printf(s, "interrupts %d, ", c->interrupts);
766 if (c->direction == PCMDIR_REC)
767 sbuf_printf(s, "overruns %d, hfree %d, sfree %d",
768 c->xruns, sndbuf_getfree(c->bufhard), sndbuf_getfree(c->bufsoft));
770 sbuf_printf(s, "underruns %d, ready %d",
771 c->xruns, sndbuf_getready(c->bufsoft));
772 sbuf_printf(s, "\n\t");
775 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "hardware" : "userland");
776 sbuf_printf(s, " -> ");
778 while (f->source != NULL)
781 sbuf_printf(s, "%s", f->class->name);
782 if (f->desc->type == FEEDER_FMT)
783 sbuf_printf(s, "(0x%08x -> 0x%08x)", f->desc->in, f->desc->out);
784 if (f->desc->type == FEEDER_RATE)
785 sbuf_printf(s, "(%d -> %d)", FEEDER_GET(f, FEEDRATE_SRC), FEEDER_GET(f, FEEDRATE_DST));
786 if (f->desc->type == FEEDER_ROOT || f->desc->type == FEEDER_MIXER)
787 sbuf_printf(s, "(0x%08x)", f->desc->out);
788 sbuf_printf(s, " -> ");
791 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "userland" : "hardware");
794 sbuf_printf(s, " (mixer only)");
797 snd_mtxunlock(d->lock);
802 /************************************************************************/
806 sysctl_hw_snd_vchans(SYSCTL_HANDLER_ARGS)
808 struct snddev_info *d;
809 struct snddev_channel *sce;
810 struct pcm_channel *c;
811 int err, oldcnt, newcnt, cnt;
817 SLIST_FOREACH(sce, &d->channels, link) {
819 if ((c->direction == PCMDIR_PLAY) && (c->flags & CHN_F_VIRTUAL))
825 err = sysctl_handle_int(oidp, &newcnt, sizeof(newcnt), req);
826 if (err == 0 && req->newptr != NULL) {
827 if (newcnt < 0 || newcnt > SND_MAXVCHANS) {
833 /* add new vchans - find a parent channel first */
834 SLIST_FOREACH(sce, &d->channels, link) {
836 /* not a candidate if not a play channel */
837 if (c->direction != PCMDIR_PLAY)
839 /* not a candidate if a virtual channel */
840 if (c->flags & CHN_F_VIRTUAL)
842 /* not a candidate if it's in use */
843 if ((c->flags & CHN_F_BUSY) && (SLIST_EMPTY(&c->children)))
846 * if we get here we're a nonvirtual play channel, and either
848 * 2) busy with children, not directly open
850 * thus we can add children
857 c->flags |= CHN_F_BUSY;
858 while (err == 0 && newcnt > cnt) {
859 err = vchan_create(c);
863 if (SLIST_EMPTY(&c->children))
864 c->flags &= ~CHN_F_BUSY;
865 } else if (newcnt < cnt) {
866 while (err == 0 && newcnt < cnt) {
867 SLIST_FOREACH(sce, &d->channels, link) {
869 if ((c->flags & (CHN_F_BUSY | CHN_F_VIRTUAL)) == CHN_F_VIRTUAL)
875 err = vchan_destroy(c);
887 /************************************************************************/
889 static moduledata_t sndpcm_mod = {
894 DECLARE_MODULE(snd_pcm, sndpcm_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
895 MODULE_VERSION(snd_pcm, PCM_MODVER);