dd83f3b6cf
- Convert sx lock to plain mutex. Since the access of /dev/sndstat is pretty much exclusive and protected by toggling sndstat_isopen, plain mutex is more than enough. - Enable SBUF_AUTOEXTEND to avoid buffer truncation.
397 lines
8.8 KiB
C
397 lines
8.8 KiB
C
/*-
|
|
* Copyright (c) 2001 Cameron Grant <cg@freebsd.org>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <dev/sound/pcm/sound.h>
|
|
#include <dev/sound/pcm/vchan.h>
|
|
#ifdef USING_MUTEX
|
|
#include <sys/sx.h>
|
|
#endif
|
|
|
|
SND_DECLARE_FILE("$FreeBSD$");
|
|
|
|
#define SS_TYPE_MODULE 0
|
|
#define SS_TYPE_FIRST 1
|
|
#define SS_TYPE_PCM 1
|
|
#define SS_TYPE_MIDI 2
|
|
#define SS_TYPE_SEQUENCER 3
|
|
#define SS_TYPE_LAST 3
|
|
|
|
static d_open_t sndstat_open;
|
|
static d_close_t sndstat_close;
|
|
static d_read_t sndstat_read;
|
|
|
|
static struct cdevsw sndstat_cdevsw = {
|
|
.d_version = D_VERSION,
|
|
.d_flags = D_NEEDGIANT,
|
|
.d_open = sndstat_open,
|
|
.d_close = sndstat_close,
|
|
.d_read = sndstat_read,
|
|
.d_name = "sndstat",
|
|
};
|
|
|
|
struct sndstat_entry {
|
|
SLIST_ENTRY(sndstat_entry) link;
|
|
device_t dev;
|
|
char *str;
|
|
sndstat_handler handler;
|
|
int type, unit;
|
|
};
|
|
|
|
#ifdef USING_MUTEX
|
|
static struct mtx sndstat_lock;
|
|
#endif
|
|
static struct sbuf sndstat_sbuf;
|
|
static struct cdev *sndstat_dev = 0;
|
|
static int sndstat_isopen = 0;
|
|
static int sndstat_bufptr;
|
|
static int sndstat_maxunit = -1;
|
|
static int sndstat_files = 0;
|
|
|
|
static SLIST_HEAD(, sndstat_entry) sndstat_devlist = SLIST_HEAD_INITIALIZER(none);
|
|
|
|
#ifdef SND_DEBUG
|
|
SYSCTL_INT(_hw_snd, OID_AUTO, sndstat_isopen, CTLFLAG_RW,
|
|
&sndstat_isopen, 1, "sndstat emergency exit");
|
|
#endif
|
|
|
|
int snd_verbose = 1;
|
|
#ifdef USING_MUTEX
|
|
TUNABLE_INT("hw.snd.verbose", &snd_verbose);
|
|
#else
|
|
TUNABLE_INT_DECL("hw.snd.verbose", 1, snd_verbose);
|
|
#endif
|
|
|
|
static int sndstat_prepare(struct sbuf *s);
|
|
|
|
static int
|
|
sysctl_hw_sndverbose(SYSCTL_HANDLER_ARGS)
|
|
{
|
|
int error, verbose;
|
|
|
|
verbose = snd_verbose;
|
|
error = sysctl_handle_int(oidp, &verbose, sizeof(verbose), req);
|
|
if (error == 0 && req->newptr != NULL) {
|
|
mtx_lock(&sndstat_lock);
|
|
if (verbose < 0 || verbose > 4)
|
|
error = EINVAL;
|
|
else
|
|
snd_verbose = verbose;
|
|
mtx_unlock(&sndstat_lock);
|
|
}
|
|
return error;
|
|
}
|
|
SYSCTL_PROC(_hw_snd, OID_AUTO, verbose, CTLTYPE_INT | CTLFLAG_RW,
|
|
0, sizeof(int), sysctl_hw_sndverbose, "I", "verbosity level");
|
|
|
|
static int
|
|
sndstat_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
|
|
{
|
|
int error;
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
if (sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBUSY;
|
|
}
|
|
sndstat_isopen = 1;
|
|
mtx_unlock(&sndstat_lock);
|
|
if (sbuf_new(&sndstat_sbuf, NULL, 4096, SBUF_AUTOEXTEND) == NULL) {
|
|
error = ENXIO;
|
|
goto out;
|
|
}
|
|
sndstat_bufptr = 0;
|
|
error = (sndstat_prepare(&sndstat_sbuf) > 0) ? 0 : ENOMEM;
|
|
out:
|
|
if (error) {
|
|
mtx_lock(&sndstat_lock);
|
|
sndstat_isopen = 0;
|
|
mtx_unlock(&sndstat_lock);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
sndstat_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
|
|
{
|
|
mtx_lock(&sndstat_lock);
|
|
if (!sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBADF;
|
|
}
|
|
|
|
mtx_unlock(&sndstat_lock);
|
|
sbuf_delete(&sndstat_sbuf);
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
sndstat_isopen = 0;
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sndstat_read(struct cdev *i_dev, struct uio *buf, int flag)
|
|
{
|
|
int l, err;
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
if (!sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBADF;
|
|
}
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
l = min(buf->uio_resid, sbuf_len(&sndstat_sbuf) - sndstat_bufptr);
|
|
err = (l > 0)? uiomove(sbuf_data(&sndstat_sbuf) + sndstat_bufptr, l, buf) : 0;
|
|
sndstat_bufptr += l;
|
|
|
|
return err;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
static struct sndstat_entry *
|
|
sndstat_find(int type, int unit)
|
|
{
|
|
struct sndstat_entry *ent;
|
|
|
|
SLIST_FOREACH(ent, &sndstat_devlist, link) {
|
|
if (ent->type == type && ent->unit == unit)
|
|
return ent;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
sndstat_acquire(void)
|
|
{
|
|
mtx_lock(&sndstat_lock);
|
|
if (sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBUSY;
|
|
}
|
|
sndstat_isopen = 1;
|
|
mtx_unlock(&sndstat_lock);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sndstat_release(void)
|
|
{
|
|
mtx_lock(&sndstat_lock);
|
|
if (!sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBADF;
|
|
}
|
|
sndstat_isopen = 0;
|
|
mtx_unlock(&sndstat_lock);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sndstat_register(device_t dev, char *str, sndstat_handler handler)
|
|
{
|
|
struct sndstat_entry *ent;
|
|
const char *devtype;
|
|
int type, unit;
|
|
|
|
if (dev) {
|
|
unit = device_get_unit(dev);
|
|
devtype = device_get_name(dev);
|
|
if (!strcmp(devtype, "pcm"))
|
|
type = SS_TYPE_PCM;
|
|
else if (!strcmp(devtype, "midi"))
|
|
type = SS_TYPE_MIDI;
|
|
else if (!strcmp(devtype, "sequencer"))
|
|
type = SS_TYPE_SEQUENCER;
|
|
else
|
|
return EINVAL;
|
|
} else {
|
|
type = SS_TYPE_MODULE;
|
|
unit = -1;
|
|
}
|
|
|
|
ent = malloc(sizeof *ent, M_DEVBUF, M_WAITOK | M_ZERO);
|
|
ent->dev = dev;
|
|
ent->str = str;
|
|
ent->type = type;
|
|
ent->unit = unit;
|
|
ent->handler = handler;
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
SLIST_INSERT_HEAD(&sndstat_devlist, ent, link);
|
|
if (type == SS_TYPE_MODULE)
|
|
sndstat_files++;
|
|
sndstat_maxunit = (unit > sndstat_maxunit)? unit : sndstat_maxunit;
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
sndstat_registerfile(char *str)
|
|
{
|
|
return sndstat_register(NULL, str, NULL);
|
|
}
|
|
|
|
int
|
|
sndstat_unregister(device_t dev)
|
|
{
|
|
struct sndstat_entry *ent;
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
SLIST_FOREACH(ent, &sndstat_devlist, link) {
|
|
if (ent->dev == dev) {
|
|
SLIST_REMOVE(&sndstat_devlist, ent, sndstat_entry, link);
|
|
mtx_unlock(&sndstat_lock);
|
|
free(ent, M_DEVBUF);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
return ENXIO;
|
|
}
|
|
|
|
int
|
|
sndstat_unregisterfile(char *str)
|
|
{
|
|
struct sndstat_entry *ent;
|
|
|
|
mtx_lock(&sndstat_lock);
|
|
SLIST_FOREACH(ent, &sndstat_devlist, link) {
|
|
if (ent->dev == NULL && ent->str == str) {
|
|
SLIST_REMOVE(&sndstat_devlist, ent, sndstat_entry, link);
|
|
sndstat_files--;
|
|
mtx_unlock(&sndstat_lock);
|
|
free(ent, M_DEVBUF);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
return ENXIO;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
static int
|
|
sndstat_prepare(struct sbuf *s)
|
|
{
|
|
struct sndstat_entry *ent;
|
|
int i, j;
|
|
|
|
sbuf_printf(s, "FreeBSD Audio Driver (newpcm: %ubit)\n",
|
|
(unsigned int)sizeof(intpcm_t) << 3);
|
|
if (SLIST_EMPTY(&sndstat_devlist)) {
|
|
sbuf_printf(s, "No devices installed.\n");
|
|
sbuf_finish(s);
|
|
return sbuf_len(s);
|
|
}
|
|
|
|
sbuf_printf(s, "Installed devices:\n");
|
|
|
|
for (i = 0; i <= sndstat_maxunit; i++) {
|
|
for (j = SS_TYPE_FIRST; j <= SS_TYPE_LAST; j++) {
|
|
ent = sndstat_find(j, i);
|
|
if (!ent)
|
|
continue;
|
|
sbuf_printf(s, "%s:", device_get_nameunit(ent->dev));
|
|
sbuf_printf(s, " <%s>", device_get_desc(ent->dev));
|
|
sbuf_printf(s, " %s", ent->str);
|
|
if (ent->handler)
|
|
ent->handler(s, ent->dev, snd_verbose);
|
|
else
|
|
sbuf_printf(s, " [no handler]");
|
|
sbuf_printf(s, "\n");
|
|
}
|
|
}
|
|
|
|
if (snd_verbose >= 3 && sndstat_files > 0) {
|
|
sbuf_printf(s, "\nFile Versions:\n");
|
|
|
|
SLIST_FOREACH(ent, &sndstat_devlist, link) {
|
|
if (ent->dev == NULL && ent->str != NULL)
|
|
sbuf_printf(s, "%s\n", ent->str);
|
|
}
|
|
}
|
|
|
|
sbuf_finish(s);
|
|
return sbuf_len(s);
|
|
}
|
|
|
|
static int
|
|
sndstat_init(void)
|
|
{
|
|
mtx_init(&sndstat_lock, "sndstat", "sndstat lock", MTX_DEF);
|
|
sndstat_dev = make_dev(&sndstat_cdevsw, SND_DEV_STATUS, UID_ROOT, GID_WHEEL, 0444, "sndstat");
|
|
|
|
return (sndstat_dev != 0)? 0 : ENXIO;
|
|
}
|
|
|
|
static int
|
|
sndstat_uninit(void)
|
|
{
|
|
mtx_lock(&sndstat_lock);
|
|
if (sndstat_isopen) {
|
|
mtx_unlock(&sndstat_lock);
|
|
return EBUSY;
|
|
}
|
|
|
|
sndstat_isopen = 1;
|
|
mtx_unlock(&sndstat_lock);
|
|
|
|
if (sndstat_dev)
|
|
destroy_dev(sndstat_dev);
|
|
sndstat_dev = 0;
|
|
|
|
mtx_destroy(&sndstat_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
sndstat_sysinit(void *p)
|
|
{
|
|
sndstat_init();
|
|
}
|
|
|
|
static void
|
|
sndstat_sysuninit(void *p)
|
|
{
|
|
int error;
|
|
|
|
error = sndstat_uninit();
|
|
KASSERT(error == 0, ("%s: error = %d", __func__, error));
|
|
}
|
|
|
|
SYSINIT(sndstat_sysinit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysinit, NULL);
|
|
SYSUNINIT(sndstat_sysuninit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysuninit, NULL);
|
|
|
|
|