Device layer rollup commit.
[dragonfly.git] / sys / dev / sound / pcm / sndstat.c
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.6 2004/05/19 22:52:50 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.6 2004/05/19 22:52:50 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, 0, 0);
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, 0, 0);
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