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.2 2003/06/17 04:28:31 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.2 2003/06/17 04:28:31 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);
296 sysctl_hw_snd_unit(SYSCTL_HANDLER_ARGS)
298 struct snddev_info *d;
302 error = sysctl_handle_int(oidp, &unit, sizeof(unit), req);
303 if (error == 0 && req->newptr != NULL) {
304 if (unit < 0 || unit >= devclass_get_maxunit(pcm_devclass))
306 d = devclass_get_softc(pcm_devclass, unit);
307 if (d == NULL || SLIST_EMPTY(&d->channels))
313 SYSCTL_PROC(_hw_snd, OID_AUTO, unit, CTLTYPE_INT | CTLFLAG_RW,
314 0, sizeof(int), sysctl_hw_snd_unit, "I", "");
318 sysctl_hw_snd_maxautovchans(SYSCTL_HANDLER_ARGS)
320 struct snddev_info *d;
323 v = snd_maxautovchans;
324 error = sysctl_handle_int(oidp, &v, sizeof(v), req);
325 if (error == 0 && req->newptr != NULL) {
326 if (v < 0 || v >= SND_MAXVCHANS)
328 if (v != snd_maxautovchans) {
329 for (i = 0; i < devclass_get_maxunit(pcm_devclass); i++) {
330 d = devclass_get_softc(pcm_devclass, i);
333 pcm_setmaxautovchans(d, v);
336 snd_maxautovchans = v;
340 SYSCTL_PROC(_hw_snd, OID_AUTO, maxautovchans, CTLTYPE_INT | CTLFLAG_RW,
341 0, sizeof(int), sysctl_hw_snd_maxautovchans, "I", "");
344 pcm_chn_create(struct snddev_info *d, struct pcm_channel *parent, kobj_class_t cls, int dir, void *devinfo)
346 struct pcm_channel *ch;
353 pnum = &d->playcount;
364 pnum = &d->vchancount;
371 ch = malloc(sizeof(*ch), M_DEVBUF, M_WAITOK | M_ZERO);
375 ch->methods = kobj_create(cls, M_DEVBUF, M_WAITOK);
385 ch->parentsnddev = d;
386 ch->parentchannel = parent;
388 snprintf(ch->name, 32, "%s:%s:%d", device_get_nameunit(d->dev), dirs, ch->num);
390 err = chn_init(ch, devinfo, dir);
392 device_printf(d->dev, "chn_init(%s) failed: err = %d\n", ch->name, err);
393 kobj_delete(ch->methods, M_DEVBUF);
404 pcm_chn_destroy(struct pcm_channel *ch)
406 struct snddev_info *d;
409 d = ch->parentsnddev;
412 device_printf(d->dev, "chn_kill(%s) failed, err = %d\n", ch->name, err);
416 if (ch->direction == PCMDIR_REC)
418 else if (ch->flags & CHN_F_VIRTUAL)
423 kobj_delete(ch->methods, M_DEVBUF);
430 pcm_chn_add(struct snddev_info *d, struct pcm_channel *ch, int mkdev)
432 struct snddev_channel *sce, *tmp, *after;
433 int unit = device_get_unit(d->dev);
435 snd_mtxlock(d->lock);
437 sce = malloc(sizeof(*sce), M_DEVBUF, M_WAITOK | M_ZERO);
439 snd_mtxunlock(d->lock);
444 if (SLIST_EMPTY(&d->channels)) {
445 SLIST_INSERT_HEAD(&d->channels, sce, link);
448 SLIST_FOREACH(tmp, &d->channels, link) {
451 SLIST_INSERT_AFTER(after, sce, link);
455 dsp_register(unit, d->devcount++);
456 if (ch->direction == PCMDIR_REC)
457 dsp_registerrec(unit, ch->num);
460 snd_mtxunlock(d->lock);
466 pcm_chn_remove(struct snddev_info *d, struct pcm_channel *ch, int rmdev)
468 struct snddev_channel *sce;
469 int unit = device_get_unit(d->dev);
471 snd_mtxlock(d->lock);
472 SLIST_FOREACH(sce, &d->channels, link) {
473 if (sce->channel == ch)
476 snd_mtxunlock(d->lock);
479 SLIST_REMOVE(&d->channels, sce, snddev_channel, link);
483 dsp_unregister(unit, --d->devcount);
484 if (ch->direction == PCMDIR_REC)
485 dsp_unregisterrec(unit, ch->num);
487 snd_mtxunlock(d->lock);
493 pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
495 struct snddev_info *d = device_get_softc(dev);
496 struct pcm_channel *ch;
499 ch = pcm_chn_create(d, NULL, cls, dir, devinfo);
501 device_printf(d->dev, "pcm_chn_create(%s, %d, %p) failed\n", cls->name, dir, devinfo);
505 err = pcm_chn_add(d, ch, 1);
507 device_printf(d->dev, "pcm_chn_add(%s) failed, err=%d\n", ch->name, err);
512 if (snd_maxautovchans > 0 && (d->flags & SD_F_AUTOVCHAN)) {
513 ch->flags |= CHN_F_BUSY;
514 err = vchan_create(ch);
516 device_printf(d->dev, "vchan_create(%s) == %d\n", ch->name, err);
517 ch->flags &= ~CHN_F_BUSY;
525 pcm_killchan(device_t dev)
527 struct snddev_info *d = device_get_softc(dev);
528 struct snddev_channel *sce;
529 struct pcm_channel *ch;
532 snd_mtxlock(d->lock);
533 sce = SLIST_FIRST(&d->channels);
534 snd_mtxunlock(d->lock);
537 error = pcm_chn_remove(d, sce->channel, 1);
540 return (pcm_chn_destroy(ch));
544 pcm_setstatus(device_t dev, char *str)
546 struct snddev_info *d = device_get_softc(dev);
548 snd_mtxlock(d->lock);
549 strncpy(d->status, str, SND_STATUSLEN);
550 snd_mtxunlock(d->lock);
555 pcm_getflags(device_t dev)
557 struct snddev_info *d = device_get_softc(dev);
563 pcm_setflags(device_t dev, u_int32_t val)
565 struct snddev_info *d = device_get_softc(dev);
571 pcm_getdevinfo(device_t dev)
573 struct snddev_info *d = device_get_softc(dev);
579 pcm_getbuffersize(device_t dev, unsigned int min, unsigned int deflt, unsigned int max)
581 struct snddev_info *d = device_get_softc(dev);
585 if (resource_int_value(device_get_name(dev), device_get_unit(dev), "buffersize", &sz) == 0) {
589 device_printf(dev, "'buffersize=%d' hint is out of range (%d-%d), using %d\n", x, min, max, sz);
596 device_printf(dev, "'buffersize=%d' hint is not a power of 2, using %d\n", sz, x);
609 pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
611 struct snddev_info *d = device_get_softc(dev);
614 device_printf(dev, "disabled due to an error while initialising: %d\n", pcm_veto_load);
619 d->lock = snd_mtxcreate(device_get_nameunit(dev), "sound cdev");
620 snd_mtxlock(d->lock);
624 d->devinfo = devinfo;
631 if (((numplay == 0) || (numrec == 0)) && (numplay != numrec))
632 d->flags |= SD_F_SIMPLEX;
634 d->fakechan = fkchan_setup(dev);
635 chn_init(d->fakechan, NULL, 0);
638 sysctl_ctx_init(&d->sysctl_tree);
639 d->sysctl_tree_top = SYSCTL_ADD_NODE(&d->sysctl_tree,
640 SYSCTL_STATIC_CHILDREN(_hw_snd), OID_AUTO,
641 device_get_nameunit(dev), CTLFLAG_RD, 0, "");
642 if (d->sysctl_tree_top == NULL) {
643 sysctl_ctx_free(&d->sysctl_tree);
646 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
647 OID_AUTO, "buffersize", CTLFLAG_RD, &d->bufsz, 0, "");
652 d->flags |= SD_F_AUTOVCHAN;
654 snd_mtxunlock(d->lock);
655 sndstat_register(dev, d->status, sndstat_prepare_pcm);
658 snd_mtxfree(d->lock);
663 pcm_unregister(device_t dev)
665 struct snddev_info *d = device_get_softc(dev);
666 struct snddev_channel *sce;
667 struct pcm_channel *ch;
669 snd_mtxlock(d->lock);
671 device_printf(dev, "unregister: operation in progress\n");
672 snd_mtxunlock(d->lock);
675 if (sndstat_busy() != 0) {
676 device_printf(dev, "unregister: sndstat busy\n");
677 snd_mtxunlock(d->lock);
680 SLIST_FOREACH(sce, &d->channels, link) {
682 if (ch->refcount > 0) {
683 device_printf(dev, "unregister: channel %s busy (pid %d)\n", ch->name, ch->pid);
684 snd_mtxunlock(d->lock);
688 if (mixer_uninit(dev)) {
689 device_printf(dev, "unregister: mixer busy\n");
690 snd_mtxunlock(d->lock);
695 d->sysctl_tree_top = NULL;
696 sysctl_ctx_free(&d->sysctl_tree);
698 while (!SLIST_EMPTY(&d->channels))
701 chn_kill(d->fakechan);
702 fkchan_kill(d->fakechan);
704 snd_mtxfree(d->lock);
708 /************************************************************************/
711 sndstat_prepare_pcm(struct sbuf *s, device_t dev, int verbose)
713 struct snddev_info *d;
714 struct snddev_channel *sce;
715 struct pcm_channel *c;
716 struct pcm_feeder *f;
722 d = device_get_softc(dev);
726 snd_mtxlock(d->lock);
727 if (!SLIST_EMPTY(&d->channels)) {
729 SLIST_FOREACH(sce, &d->channels, link) {
731 if (c->direction == PCMDIR_PLAY) {
732 if (c->flags & CHN_F_VIRTUAL)
739 sbuf_printf(s, " (%dp/%dr/%dv channels%s%s)", d->playcount, d->reccount, d->vchancount,
740 (d->flags & SD_F_SIMPLEX)? "" : " duplex",
742 (device_get_unit(dev) == snd_unit)? " default" : ""
749 SLIST_FOREACH(sce, &d->channels, link) {
751 sbuf_printf(s, "\n\t");
753 sbuf_printf(s, "%s[%s]: ", c->parentchannel? c->parentchannel->name : "", c->name);
754 sbuf_printf(s, "spd %d", c->speed);
755 if (c->speed != sndbuf_getspd(c->bufhard))
756 sbuf_printf(s, "/%d", sndbuf_getspd(c->bufhard));
757 sbuf_printf(s, ", fmt 0x%08x", c->format);
758 if (c->format != sndbuf_getfmt(c->bufhard))
759 sbuf_printf(s, "/0x%08x", sndbuf_getfmt(c->bufhard));
760 sbuf_printf(s, ", flags %08x", c->flags);
762 sbuf_printf(s, ", pid %d", c->pid);
763 sbuf_printf(s, "\n\t");
765 if (c->bufhard != NULL && c->bufsoft != NULL) {
766 sbuf_printf(s, "interrupts %d, ", c->interrupts);
767 if (c->direction == PCMDIR_REC)
768 sbuf_printf(s, "overruns %d, hfree %d, sfree %d",
769 c->xruns, sndbuf_getfree(c->bufhard), sndbuf_getfree(c->bufsoft));
771 sbuf_printf(s, "underruns %d, ready %d",
772 c->xruns, sndbuf_getready(c->bufsoft));
773 sbuf_printf(s, "\n\t");
776 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "hardware" : "userland");
777 sbuf_printf(s, " -> ");
779 while (f->source != NULL)
782 sbuf_printf(s, "%s", f->class->name);
783 if (f->desc->type == FEEDER_FMT)
784 sbuf_printf(s, "(0x%08x -> 0x%08x)", f->desc->in, f->desc->out);
785 if (f->desc->type == FEEDER_RATE)
786 sbuf_printf(s, "(%d -> %d)", FEEDER_GET(f, FEEDRATE_SRC), FEEDER_GET(f, FEEDRATE_DST));
787 if (f->desc->type == FEEDER_ROOT || f->desc->type == FEEDER_MIXER)
788 sbuf_printf(s, "(0x%08x)", f->desc->out);
789 sbuf_printf(s, " -> ");
792 sbuf_printf(s, "{%s}", (c->direction == PCMDIR_REC)? "userland" : "hardware");
796 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
858 c->flags |= CHN_F_BUSY;
859 while (err == 0 && newcnt > cnt) {
860 err = vchan_create(c);
864 if (SLIST_EMPTY(&c->children))
865 c->flags &= ~CHN_F_BUSY;
866 } else if (newcnt < cnt) {
867 while (err == 0 && newcnt < cnt) {
868 SLIST_FOREACH(sce, &d->channels, link) {
870 if ((c->flags & (CHN_F_BUSY | CHN_F_VIRTUAL)) == CHN_F_VIRTUAL)
876 err = vchan_destroy(c);
888 /************************************************************************/
890 static moduledata_t sndpcm_mod = {
895 DECLARE_MODULE(snd_pcm, sndpcm_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
896 MODULE_VERSION(snd_pcm, PCM_MODVER);