xref: /dragonfly/sys/dev/sound/pcm/sndstat.c (revision 2cd2d2b5) 
1 /*
2  * Copyright (c) 2001 Cameron Grant <gandalf@vilnya.demon.co.uk>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/sound/pcm/sndstat.c,v 1.4.2.2 2002/04/22 15:49:36 cg Exp $
27  * $DragonFly: src/sys/dev/sound/pcm/sndstat.c,v 1.7 2004/05/21 01:14:27 dillon Exp $
28  */
29 
30 #include <dev/sound/pcm/sound.h>
31 #include <dev/sound/pcm/vchan.h>
32 
33 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/sndstat.c,v 1.7 2004/05/21 01:14:27 dillon Exp $");
34 
35 #define	SS_TYPE_MODULE		0
36 #define	SS_TYPE_FIRST		1
37 #define	SS_TYPE_PCM		1
38 #define	SS_TYPE_MIDI		2
39 #define	SS_TYPE_SEQUENCER	3
40 #define	SS_TYPE_LAST		3
41 
42 static d_open_t sndstat_open;
43 static d_close_t sndstat_close;
44 static d_read_t sndstat_read;
45 
46 static struct cdevsw sndstat_cdevsw = {
47 	/* name */	"sndstat",
48 	/* maj */	SND_CDEV_MAJOR,
49 	/* flags */	0,
50 	/* port */	NULL,
51 	/* clone */	NULL,
52 
53 	/* open */	sndstat_open,
54 	/* close */	sndstat_close,
55 	/* read */	sndstat_read,
56 	/* write */	nowrite,
57 	/* ioctl */	noioctl,
58 	/* poll */	nopoll,
59 	/* mmap */	nommap,
60 	/* strategy */	nostrategy,
61 	/* dump */	nodump,
62 	/* psize */	nopsize
63 };
64 
65 struct sndstat_entry {
66 	SLIST_ENTRY(sndstat_entry) link;
67 	device_t dev;
68 	char *str;
69 	sndstat_handler handler;
70 	int type, unit;
71 };
72 
73 static struct sbuf sndstat_sbuf;
74 static int sndstat_isopen = 0;
75 static int sndstat_bufptr;
76 static int sndstat_maxunit = -1;
77 static int sndstat_files = 0;
78 
79 static SLIST_HEAD(, sndstat_entry) sndstat_devlist = SLIST_HEAD_INITIALIZER(none);
80 
81 static int sndstat_verbose = 1;
82 #ifdef	USING_MUTEX
83 TUNABLE_INT("hw.snd.verbose", &sndstat_verbose);
84 #else
85 TUNABLE_INT_DECL("hw.snd.verbose", 1, sndstat_verbose);
86 #endif
87 
88 static int sndstat_prepare(struct sbuf *s);
89 
90 static int
91 sysctl_hw_sndverbose(SYSCTL_HANDLER_ARGS)
92 {
93 	intrmask_t s;
94 	int error, verbose;
95 
96 	verbose = sndstat_verbose;
97 	error = sysctl_handle_int(oidp, &verbose, sizeof(verbose), req);
98 	if (error == 0 && req->newptr != NULL) {
99 		s = spltty();
100 		if (verbose < 0 || verbose > 3)
101 			error = EINVAL;
102 		else
103 			sndstat_verbose = verbose;
104 		splx(s);
105 	}
106 	return error;
107 }
108 SYSCTL_PROC(_hw_snd, OID_AUTO, verbose, CTLTYPE_INT | CTLFLAG_RW,
109             0, sizeof(int), sysctl_hw_sndverbose, "I", "");
110 
111 static int
112 sndstat_open(dev_t i_dev, int flags, int mode, struct thread *td)
113 {
114 	intrmask_t s;
115 	int err;
116 
117 	s = spltty();
118 	if (sndstat_isopen) {
119 		splx(s);
120 		return EBUSY;
121 	}
122 	if (sbuf_new(&sndstat_sbuf, NULL, 4096, 0) == NULL) {
123 		splx(s);
124 		return ENXIO;
125 	}
126 	sndstat_bufptr = 0;
127 	err = (sndstat_prepare(&sndstat_sbuf) > 0)? 0 : ENOMEM;
128 	if (!err)
129 		sndstat_isopen = 1;
130 
131 	splx(s);
132 	return err;
133 }
134 
135 static int
136 sndstat_close(dev_t i_dev, int flags, int mode, struct thread *td)
137 {
138 	intrmask_t s;
139 
140 	s = spltty();
141 	if (!sndstat_isopen) {
142 		splx(s);
143 		return EBADF;
144 	}
145 	sbuf_delete(&sndstat_sbuf);
146 	sndstat_isopen = 0;
147 
148 	splx(s);
149 	return 0;
150 }
151 
152 static int
153 sndstat_read(dev_t i_dev, struct uio *buf, int flag)
154 {
155 	intrmask_t s;
156 	int l, err;
157 
158 	s = spltty();
159 	if (!sndstat_isopen) {
160 		splx(s);
161 		return EBADF;
162 	}
163     	l = min(buf->uio_resid, sbuf_len(&sndstat_sbuf) - sndstat_bufptr);
164 	err = (l > 0)? uiomove(sbuf_data(&sndstat_sbuf) + sndstat_bufptr, l, buf) : 0;
165 	sndstat_bufptr += l;
166 
167 	splx(s);
168 	return err;
169 }
170 
171 /************************************************************************/
172 
173 static struct sndstat_entry *
174 sndstat_find(int type, int unit)
175 {
176 	struct sndstat_entry *ent;
177 
178 	SLIST_FOREACH(ent, &sndstat_devlist, link) {
179 		if (ent->type == type && ent->unit == unit)
180 			return ent;
181 	}
182 
183 	return NULL;
184 }
185 
186 int
187 sndstat_register(device_t dev, char *str, sndstat_handler handler)
188 {
189 	intrmask_t s;
190 	struct sndstat_entry *ent;
191 	const char *devtype;
192 	int type, unit;
193 
194 	if (dev) {
195 		unit = device_get_unit(dev);
196 		devtype = device_get_name(dev);
197 		if (!strcmp(devtype, "pcm"))
198 			type = SS_TYPE_PCM;
199 		else if (!strcmp(devtype, "midi"))
200 			type = SS_TYPE_MIDI;
201 		else if (!strcmp(devtype, "sequencer"))
202 			type = SS_TYPE_SEQUENCER;
203 		else
204 			return EINVAL;
205 	} else {
206 		type = SS_TYPE_MODULE;
207 		unit = -1;
208 	}
209 
210 	ent = malloc(sizeof *ent, M_DEVBUF, M_ZERO | M_WAITOK);
211 	if (!ent)
212 		return ENOSPC;
213 
214 	ent->dev = dev;
215 	ent->str = str;
216 	ent->type = type;
217 	ent->unit = unit;
218 	ent->handler = handler;
219 
220 	s = spltty();
221 	SLIST_INSERT_HEAD(&sndstat_devlist, ent, link);
222 	if (type == SS_TYPE_MODULE)
223 		sndstat_files++;
224 	sndstat_maxunit = (unit > sndstat_maxunit)? unit : sndstat_maxunit;
225 	splx(s);
226 
227 	return 0;
228 }
229 
230 int
231 sndstat_registerfile(char *str)
232 {
233 	return sndstat_register(NULL, str, NULL);
234 }
235 
236 int
237 sndstat_unregister(device_t dev)
238 {
239 	intrmask_t s;
240 	struct sndstat_entry *ent;
241 
242 	s = spltty();
243 	SLIST_FOREACH(ent, &sndstat_devlist, link) {
244 		if (ent->dev == dev) {
245 			SLIST_REMOVE(&sndstat_devlist, ent, sndstat_entry, link);
246 			free(ent, M_DEVBUF);
247 			splx(s);
248 
249 			return 0;
250 		}
251 	}
252 	splx(s);
253 
254 	return ENXIO;
255 }
256 
257 int
258 sndstat_unregisterfile(char *str)
259 {
260 	intrmask_t s;
261 	struct sndstat_entry *ent;
262 
263 	s = spltty();
264 	SLIST_FOREACH(ent, &sndstat_devlist, link) {
265 		if (ent->dev == NULL && ent->str == str) {
266 			SLIST_REMOVE(&sndstat_devlist, ent, sndstat_entry, link);
267 			free(ent, M_DEVBUF);
268 			sndstat_files--;
269 			splx(s);
270 
271 			return 0;
272 		}
273 	}
274 	splx(s);
275 
276 	return ENXIO;
277 }
278 
279 /************************************************************************/
280 
281 static int
282 sndstat_prepare(struct sbuf *s)
283 {
284 	struct sndstat_entry *ent;
285     	int i, j;
286 
287 	sbuf_printf(s, "FreeBSD Audio Driver (newpcm)\n");
288 	if (SLIST_EMPTY(&sndstat_devlist)) {
289 		sbuf_printf(s, "No devices installed.\n");
290 		sbuf_finish(s);
291     		return sbuf_len(s);
292 	}
293 
294 	sbuf_printf(s, "Installed devices:\n");
295 
296     	for (i = 0; i <= sndstat_maxunit; i++) {
297 		for (j = SS_TYPE_FIRST; j <= SS_TYPE_LAST; j++) {
298 			ent = sndstat_find(j, i);
299 			if (!ent)
300 				continue;
301 			sbuf_printf(s, "%s:", device_get_nameunit(ent->dev));
302 			sbuf_printf(s, " <%s>", device_get_desc(ent->dev));
303 			sbuf_printf(s, " %s", ent->str);
304 			if (ent->handler)
305 				ent->handler(s, ent->dev, sndstat_verbose);
306 			else
307 				sbuf_printf(s, " [no handler]");
308 			sbuf_printf(s, "\n");
309 		}
310     	}
311 
312 	if (sndstat_verbose >= 3 && sndstat_files > 0) {
313 		sbuf_printf(s, "\nFile Versions:\n");
314 
315 		SLIST_FOREACH(ent, &sndstat_devlist, link) {
316 			if (ent->dev == NULL && ent->str != NULL)
317 				sbuf_printf(s, "%s\n", ent->str);
318 		}
319 	}
320 
321 	sbuf_finish(s);
322     	return sbuf_len(s);
323 }
324 
325 static int
326 sndstat_init(void)
327 {
328 	cdevsw_add(&sndstat_cdevsw, -1, SND_DEV_STATUS);
329 	make_dev(&sndstat_cdevsw, SND_DEV_STATUS,
330 		UID_ROOT, GID_WHEEL, 0444, "sndstat");
331 	return (0);
332 }
333 
334 static int
335 sndstat_uninit(void)
336 {
337 	intrmask_t s;
338 
339 	s = spltty();
340 	if (sndstat_isopen) {
341 		splx(s);
342 		return EBUSY;
343 	}
344 	cdevsw_remove(&sndstat_cdevsw, -1, SND_DEV_STATUS);
345 	splx(s);
346 	return 0;
347 }
348 
349 int
350 sndstat_busy(void)
351 {
352 	return (sndstat_isopen);
353 }
354 
355 static void
356 sndstat_sysinit(void *p)
357 {
358 	sndstat_init();
359 }
360 
361 static void
362 sndstat_sysuninit(void *p)
363 {
364 	sndstat_uninit();
365 }
366 
367 SYSINIT(sndstat_sysinit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysinit, NULL);
368 SYSUNINIT(sndstat_sysuninit, SI_SUB_DRIVERS, SI_ORDER_FIRST, sndstat_sysuninit, NULL);
369 
370 
371