1: /*
2: * Copyright (c) 1999 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/dsp.c,v 1.15.2.13 2002/08/30 13:53:03 orion Exp $
27: * $DragonFly: src/sys/dev/sound/pcm/dsp.c,v 1.7 2004/05/21 01:14:27 dillon Exp $
28: */
29:
30: #include <sys/param.h>
31: #include <sys/queue.h>
32:
33: #include <dev/sound/pcm/sound.h>
34:
35: SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/dsp.c,v 1.7 2004/05/21 01:14:27 dillon Exp $");
36:
37: #define OLDPCM_IOCTL
38:
39: static d_open_t dsp_open;
40: static d_close_t dsp_close;
41: static d_read_t dsp_read;
42: static d_write_t dsp_write;
43: static d_ioctl_t dsp_ioctl;
44: static d_poll_t dsp_poll;
45: static d_mmap_t dsp_mmap;
46:
47: static struct cdevsw dsp_cdevsw = {
48: /* name */ "dsp",
49: /* maj */ SND_CDEV_MAJOR,
50: /* flags */ 0,
51: /* port */ NULL,
52: /* clone */ NULL,
53:
54: /* open */ dsp_open,
55: /* close */ dsp_close,
56: /* read */ dsp_read,
57: /* write */ dsp_write,
58: /* ioctl */ dsp_ioctl,
59: /* poll */ dsp_poll,
60: /* mmap */ dsp_mmap,
61: /* strategy */ nostrategy,
62: /* dump */ nodump,
63: /* psize */ nopsize
64: };
65:
66: #ifdef USING_DEVFS
67: static eventhandler_tag dsp_ehtag;
68: #endif
69:
70: static struct snddev_info *
71: dsp_get_info(dev_t dev)
72: {
73: struct snddev_info *d;
74: int unit;
75:
76: unit = PCMUNIT(dev);
77: if (unit >= devclass_get_maxunit(pcm_devclass))
78: return NULL;
79: d = devclass_get_softc(pcm_devclass, unit);
80:
81: return d;
82: }
83:
84: static u_int32_t
85: dsp_get_flags(dev_t dev)
86: {
87: device_t bdev;
88: int unit;
89:
90: unit = PCMUNIT(dev);
91: if (unit >= devclass_get_maxunit(pcm_devclass))
92: return 0xffffffff;
93: bdev = devclass_get_device(pcm_devclass, unit);
94:
95: return pcm_getflags(bdev);
96: }
97:
98: static void
99: dsp_set_flags(dev_t dev, u_int32_t flags)
100: {
101: device_t bdev;
102: int unit;
103:
104: unit = PCMUNIT(dev);
105: if (unit >= devclass_get_maxunit(pcm_devclass))
106: return;
107: bdev = devclass_get_device(pcm_devclass, unit);
108:
109: pcm_setflags(bdev, flags);
110: }
111:
112: /*
113: * return the channels channels associated with an open device instance.
114: * set the priority if the device is simplex and one direction (only) is
115: * specified.
116: * lock channels specified.
117: */
118: static int
119: getchns(dev_t dev, struct pcm_channel **rdch, struct pcm_channel **wrch, u_int32_t prio)
120: {
121: struct snddev_info *d;
122: u_int32_t flags;
123:
124: flags = dsp_get_flags(dev);
125: d = dsp_get_info(dev);
126: pcm_lock(d);
127: pcm_inprog(d, 1);
128: KASSERT((flags & SD_F_PRIO_SET) != SD_F_PRIO_SET, \
129: ("getchns: read and write both prioritised"));
130:
131: if ((flags & SD_F_PRIO_SET) == 0 && (prio != (SD_F_PRIO_RD | SD_F_PRIO_WR))) {
132: flags |= prio & (SD_F_PRIO_RD | SD_F_PRIO_WR);
133: dsp_set_flags(dev, flags);
134: }
135:
136: *rdch = dev->si_drv1;
137: *wrch = dev->si_drv2;
138: if ((flags & SD_F_SIMPLEX) && (flags & SD_F_PRIO_SET)) {
139: if (prio) {
140: if (*rdch && flags & SD_F_PRIO_WR) {
141: dev->si_drv1 = NULL;
142: *rdch = pcm_getfakechan(d);
143: } else if (*wrch && flags & SD_F_PRIO_RD) {
144: dev->si_drv2 = NULL;
145: *wrch = pcm_getfakechan(d);
146: }
147: }
148:
149: pcm_getfakechan(d)->flags |= CHN_F_BUSY;
150: }
151: pcm_unlock(d);
152:
153: if (*rdch && *rdch != pcm_getfakechan(d) && (prio & SD_F_PRIO_RD))
154: CHN_LOCK(*rdch);
155: if (*wrch && *wrch != pcm_getfakechan(d) && (prio & SD_F_PRIO_WR))
156: CHN_LOCK(*wrch);
157:
158: return 0;
159: }
160:
161: /* unlock specified channels */
162: static void
163: relchns(dev_t dev, struct pcm_channel *rdch, struct pcm_channel *wrch, u_int32_t prio)
164: {
165: struct snddev_info *d;
166:
167: d = dsp_get_info(dev);
168: if (wrch && wrch != pcm_getfakechan(d) && (prio & SD_F_PRIO_WR))
169: CHN_UNLOCK(wrch);
170: if (rdch && rdch != pcm_getfakechan(d) && (prio & SD_F_PRIO_RD))
171: CHN_UNLOCK(rdch);
172: pcm_lock(d);
173: pcm_inprog(d, -1);
174: pcm_unlock(d);
175: }
176:
177: static int
178: dsp_open(dev_t i_dev, int flags, int mode, struct thread *td)
179: {
180: struct pcm_channel *rdch, *wrch;
181: struct snddev_info *d;
182: intrmask_t s;
183: u_int32_t fmt;
184: int devtype;
185: struct proc *p = td->td_proc;
186:
187: KKASSERT(p != NULL);
188:
189: s = spltty();
190: d = dsp_get_info(i_dev);
191: devtype = PCMDEV(i_dev);
192:
193: /* decide default format */
194: switch (devtype) {
195: case SND_DEV_DSP16:
196: fmt = AFMT_S16_LE;
197: break;
198:
199: case SND_DEV_DSP:
200: fmt = AFMT_U8;
201: break;
202:
203: case SND_DEV_AUDIO:
204: fmt = AFMT_MU_LAW;
205: break;
206:
207: case SND_DEV_NORESET:
208: fmt = 0;
209: break;
210:
211: case SND_DEV_DSPREC:
212: fmt = AFMT_U8;
213: if (mode & FWRITE) {
214: splx(s);
215: return EINVAL;
216: }
217: break;
218:
219: default:
220: panic("impossible devtype %d", devtype);
221: }
222:
223: /* lock snddev so nobody else can monkey with it */
224: pcm_lock(d);
225:
226: rdch = i_dev->si_drv1;
227: wrch = i_dev->si_drv2;
228:
229: if ((dsp_get_flags(i_dev) & SD_F_SIMPLEX) && (rdch || wrch)) {
230: /* simplex device, already open, exit */
231: pcm_unlock(d);
232: splx(s);
233: return EBUSY;
234: }
235:
236: if (((flags & FREAD) && rdch) || ((flags & FWRITE) && wrch)) {
237: /* device already open in one or both directions */
238: pcm_unlock(d);
239: splx(s);
240: return EBUSY;
241: }
242:
243: /* if we get here, the open request is valid */
244: if (flags & FREAD) {
245: /* open for read */
246: if (devtype == SND_DEV_DSPREC)
247: rdch = pcm_chnalloc(d, PCMDIR_REC, p->p_pid, PCMCHAN(i_dev));
248: else
249: rdch = pcm_chnalloc(d, PCMDIR_REC, p->p_pid, -1);
250: if (!rdch) {
251: /* no channel available, exit */
252: pcm_unlock(d);
253: splx(s);
254: return EBUSY;
255: }
256: /* got a channel, already locked for us */
257: }
258:
259: if (flags & FWRITE) {
260: /* open for write */
261: wrch = pcm_chnalloc(d, PCMDIR_PLAY, p->p_pid, -1);
262: if (!wrch) {
263: /* no channel available */
264: if (rdch && (flags & FREAD)) {
265: /* just opened a read channel, release it */
266: pcm_chnrelease(rdch);
267: }
268: /* exit */
269: pcm_unlock(d);
270: splx(s);
271: return EBUSY;
272: }
273: /* got a channel, already locked for us */
274: }
275:
276: i_dev->si_drv1 = rdch;
277: i_dev->si_drv2 = wrch;
278: pcm_unlock(d);
279: /* finished with snddev, new channels still locked */
280:
281: /* bump refcounts, reset and unlock any channels that we just opened */
282: if (flags & FREAD) {
283: if (chn_reset(rdch, fmt)) {
284: pcm_lock(d);
285: pcm_chnrelease(rdch);
286: if (wrch && (flags & FWRITE))
287: pcm_chnrelease(wrch);
288: pcm_unlock(d);
289: splx(s);
290: return ENODEV;
291: }
292: if (flags & O_NONBLOCK)
293: rdch->flags |= CHN_F_NBIO;
294: pcm_chnref(rdch, 1);
295: CHN_UNLOCK(rdch);
296: }
297: if (flags & FWRITE) {
298: if (chn_reset(wrch, fmt)) {
299: pcm_lock(d);
300: pcm_chnrelease(wrch);
301: if (flags & FREAD) {
302: CHN_LOCK(rdch);
303: pcm_chnref(rdch, -1);
304: pcm_chnrelease(rdch);
305: CHN_UNLOCK(rdch);
306: }
307: pcm_unlock(d);
308: splx(s);
309: return ENODEV;
310: }
311: if (flags & O_NONBLOCK)
312: wrch->flags |= CHN_F_NBIO;
313: pcm_chnref(wrch, 1);
314: CHN_UNLOCK(wrch);
315: }
316: splx(s);
317: return 0;
318: }
319:
320: static int
321: dsp_close(dev_t i_dev, int flags, int mode, struct thread *td)
322: {
323: struct pcm_channel *rdch, *wrch;
324: struct snddev_info *d;
325: intrmask_t s;
326: int exit;
327:
328: s = spltty();
329: d = dsp_get_info(i_dev);
330: pcm_lock(d);
331: rdch = i_dev->si_drv1;
332: wrch = i_dev->si_drv2;
333:
334: exit = 0;
335:
336: /* decrement refcount for each channel, exit if nonzero */
337: if (rdch) {
338: CHN_LOCK(rdch);
339: if (pcm_chnref(rdch, -1) > 0) {
340: CHN_UNLOCK(rdch);
341: exit = 1;
342: }
343: }
344: if (wrch) {
345: CHN_LOCK(wrch);
346: if (pcm_chnref(wrch, -1) > 0) {
347: CHN_UNLOCK(wrch);
348: exit = 1;
349: }
350: }
351: if (exit) {
352: pcm_unlock(d);
353: splx(s);
354: return 0;
355: }
356:
357: /* both refcounts are zero, abort and release */
358:
359: if (pcm_getfakechan(d))
360: pcm_getfakechan(d)->flags = 0;
361:
362: i_dev->si_drv1 = NULL;
363: i_dev->si_drv2 = NULL;
364:
365: dsp_set_flags(i_dev, dsp_get_flags(i_dev) & ~SD_F_TRANSIENT);
366: pcm_unlock(d);
367:
368: if (rdch) {
369: chn_abort(rdch); /* won't sleep */
370: rdch->flags &= ~(CHN_F_RUNNING | CHN_F_MAPPED | CHN_F_DEAD);
371: chn_reset(rdch, 0);
372: pcm_chnrelease(rdch);
373: }
374: if (wrch) {
375: chn_flush(wrch); /* may sleep */
376: wrch->flags &= ~(CHN_F_RUNNING | CHN_F_MAPPED | CHN_F_DEAD);
377: chn_reset(wrch, 0);
378: pcm_chnrelease(wrch);
379: }
380:
381: splx(s);
382: return 0;
383: }
384:
385: static int
386: dsp_read(dev_t i_dev, struct uio *buf, int flag)
387: {
388: struct pcm_channel *rdch, *wrch;
389: intrmask_t s;
390: int ret;
391:
392: s = spltty();
393: getchns(i_dev, &rdch, &wrch, SD_F_PRIO_RD);
394:
395: KASSERT(rdch, ("dsp_read: nonexistant channel"));
396: KASSERT(rdch->flags & CHN_F_BUSY, ("dsp_read: nonbusy channel"));
397:
398: if (rdch->flags & (CHN_F_MAPPED | CHN_F_DEAD)) {
399: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD);
400: splx(s);
401: return EINVAL;
402: }
403: if (!(rdch->flags & CHN_F_RUNNING))
404: rdch->flags |= CHN_F_RUNNING;
405: ret = chn_read(rdch, buf);
406: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD);
407:
408: splx(s);
409: return ret;
410: }
411:
412: static int
413: dsp_write(dev_t i_dev, struct uio *buf, int flag)
414: {
415: struct pcm_channel *rdch, *wrch;
416: intrmask_t s;
417: int ret;
418:
419: s = spltty();
420: getchns(i_dev, &rdch, &wrch, SD_F_PRIO_WR);
421:
422: KASSERT(wrch, ("dsp_write: nonexistant channel"));
423: KASSERT(wrch->flags & CHN_F_BUSY, ("dsp_write: nonbusy channel"));
424:
425: if (wrch->flags & (CHN_F_MAPPED | CHN_F_DEAD)) {
426: relchns(i_dev, rdch, wrch, SD_F_PRIO_WR);
427: splx(s);
428: return EINVAL;
429: }
430: if (!(wrch->flags & CHN_F_RUNNING))
431: wrch->flags |= CHN_F_RUNNING;
432: ret = chn_write(wrch, buf);
433: relchns(i_dev, rdch, wrch, SD_F_PRIO_WR);
434:
435: splx(s);
436: return ret;
437: }
438:
439: static int
440: dsp_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
441: {
442: struct pcm_channel *wrch, *rdch;
443: struct snddev_info *d;
444: intrmask_t s;
445: int kill;
446: int ret = 0, *arg_i = (int *)arg, tmp;
447:
448: /*
449: * this is an evil hack to allow broken apps to perform mixer ioctls
450: * on dsp devices.
451: */
452:
453: if (IOCGROUP(cmd) == 'M') {
454: dev_t pdev;
455:
456: pdev = make_adhoc_dev(&dsp_cdevsw,
457: PCMMKMINOR(PCMUNIT(i_dev), SND_DEV_CTL, 0));
458: return mixer_ioctl(pdev, cmd, arg, mode, td);
459: }
460:
461: s = spltty();
462: d = dsp_get_info(i_dev);
463: getchns(i_dev, &rdch, &wrch, 0);
464:
465: kill = 0;
466: if (wrch && (wrch->flags & CHN_F_DEAD))
467: kill |= 1;
468: if (rdch && (rdch->flags & CHN_F_DEAD))
469: kill |= 2;
470: if (kill == 3) {
471: relchns(i_dev, rdch, wrch, 0);
472: splx(s);
473: return EINVAL;
474: }
475: if (kill & 1)
476: wrch = NULL;
477: if (kill & 2)
478: rdch = NULL;
479:
480: switch(cmd) {
481: #ifdef OLDPCM_IOCTL
482: /*
483: * we start with the new ioctl interface.
484: */
485: case AIONWRITE: /* how many bytes can write ? */
486: /*
487: if (wrch && wrch->bufhard.dl)
488: while (chn_wrfeed(wrch) == 0);
489: */
490: *arg_i = wrch? sndbuf_getfree(wrch->bufsoft) : 0;
491: break;
492:
493: case AIOSSIZE: /* set the current blocksize */
494: {
495: struct snd_size *p = (struct snd_size *)arg;
496:
497: p->play_size = 0;
498: p->rec_size = 0;
499: if (wrch) {
500: CHN_LOCK(wrch);
501: chn_setblocksize(wrch, 2, p->play_size);
502: p->play_size = sndbuf_getblksz(wrch->bufsoft);
503: CHN_UNLOCK(wrch);
504: }
505: if (rdch) {
506: CHN_LOCK(rdch);
507: chn_setblocksize(rdch, 2, p->rec_size);
508: p->rec_size = sndbuf_getblksz(rdch->bufsoft);
509: CHN_UNLOCK(rdch);
510: }
511: }
512: break;
513: case AIOGSIZE: /* get the current blocksize */
514: {
515: struct snd_size *p = (struct snd_size *)arg;
516:
517: if (wrch)
518: p->play_size = sndbuf_getblksz(wrch->bufsoft);
519: if (rdch)
520: p->rec_size = sndbuf_getblksz(rdch->bufsoft);
521: }
522: break;
523:
524: case AIOSFMT:
525: {
526: snd_chan_param *p = (snd_chan_param *)arg;
527:
528: if (wrch) {
529: CHN_LOCK(wrch);
530: chn_setformat(wrch, p->play_format);
531: chn_setspeed(wrch, p->play_rate);
532: CHN_UNLOCK(wrch);
533: }
534: if (rdch) {
535: CHN_LOCK(rdch);
536: chn_setformat(rdch, p->rec_format);
537: chn_setspeed(rdch, p->rec_rate);
538: CHN_UNLOCK(rdch);
539: }
540: }
541: /* FALLTHROUGH */
542:
543: case AIOGFMT:
544: {
545: snd_chan_param *p = (snd_chan_param *)arg;
546:
547: p->play_rate = wrch? wrch->speed : 0;
548: p->rec_rate = rdch? rdch->speed : 0;
549: p->play_format = wrch? wrch->format : 0;
550: p->rec_format = rdch? rdch->format : 0;
551: }
552: break;
553:
554: case AIOGCAP: /* get capabilities */
555: {
556: snd_capabilities *p = (snd_capabilities *)arg;
557: struct pcmchan_caps *pcaps = NULL, *rcaps = NULL;
558: dev_t pdev;
559:
560: if (rdch) {
561: CHN_LOCK(rdch);
562: rcaps = chn_getcaps(rdch);
563: }
564: if (wrch) {
565: CHN_LOCK(wrch);
566: pcaps = chn_getcaps(wrch);
567: }
568: p->rate_min = max(rcaps? rcaps->minspeed : 0,
569: pcaps? pcaps->minspeed : 0);
570: p->rate_max = min(rcaps? rcaps->maxspeed : 1000000,
571: pcaps? pcaps->maxspeed : 1000000);
572: p->bufsize = min(rdch? sndbuf_getsize(rdch->bufsoft) : 1000000,
573: wrch? sndbuf_getsize(wrch->bufsoft) : 1000000);
574: /* XXX bad on sb16 */
575: p->formats = (rdch? chn_getformats(rdch) : 0xffffffff) &
576: (wrch? chn_getformats(wrch) : 0xffffffff);
577: if (rdch && wrch)
578: p->formats |= (dsp_get_flags(i_dev) & SD_F_SIMPLEX)? 0 : AFMT_FULLDUPLEX;
579: pdev = make_adhoc_dev(&dsp_cdevsw, PCMMKMINOR(PCMUNIT(i_dev), SND_DEV_CTL, 0));
580: p->mixers = 1; /* default: one mixer */
581: p->inputs = pdev->si_drv1? mix_getdevs(pdev->si_drv1) : 0;
582: p->left = p->right = 100;
583: if (wrch)
584: CHN_UNLOCK(wrch);
585: if (rdch)
586: CHN_UNLOCK(rdch);
587: }
588: break;
589:
590: case AIOSTOP:
591: if (*arg_i == AIOSYNC_PLAY && wrch)
592: *arg_i = chn_abort(wrch);
593: else if (*arg_i == AIOSYNC_CAPTURE && rdch)
594: *arg_i = chn_abort(rdch);
595: else {
596: printf("AIOSTOP: bad channel 0x%x\n", *arg_i);
597: *arg_i = 0;
598: }
599: break;
600:
601: case AIOSYNC:
602: printf("AIOSYNC chan 0x%03lx pos %lu unimplemented\n",
603: ((snd_sync_parm *)arg)->chan, ((snd_sync_parm *)arg)->pos);
604: break;
605: #endif
606: /*
607: * here follow the standard ioctls (filio.h etc.)
608: */
609: case FIONREAD: /* get # bytes to read */
610: /* if (rdch && rdch->bufhard.dl)
611: while (chn_rdfeed(rdch) == 0);
612: */ *arg_i = rdch? sndbuf_getready(rdch->bufsoft) : 0;
613: break;
614:
615: case FIOASYNC: /*set/clear async i/o */
616: DEB( printf("FIOASYNC\n") ; )
617: break;
618:
619: case SNDCTL_DSP_NONBLOCK:
620: case FIONBIO: /* set/clear non-blocking i/o */
621: if (rdch)
622: rdch->flags &= ~CHN_F_NBIO;
623: if (wrch)
624: wrch->flags &= ~CHN_F_NBIO;
625: if (*arg_i) {
626: if (rdch)
627: rdch->flags |= CHN_F_NBIO;
628: if (wrch)
629: wrch->flags |= CHN_F_NBIO;
630: }
631: break;
632:
633: /*
634: * Finally, here is the linux-compatible ioctl interface
635: */
636: #define THE_REAL_SNDCTL_DSP_GETBLKSIZE _IOWR('P', 4, int)
637: case THE_REAL_SNDCTL_DSP_GETBLKSIZE:
638: case SNDCTL_DSP_GETBLKSIZE:
639: if (wrch)
640: *arg_i = sndbuf_getblksz(wrch->bufsoft);
641: else if (rdch)
642: *arg_i = sndbuf_getblksz(rdch->bufsoft);
643: else
644: *arg_i = 0;
645: break ;
646:
647: case SNDCTL_DSP_SETBLKSIZE:
648: RANGE(*arg_i, 16, 65536);
649: if (wrch) {
650: CHN_LOCK(wrch);
651: chn_setblocksize(wrch, 2, *arg_i);
652: CHN_UNLOCK(wrch);
653: }
654: if (rdch) {
655: CHN_LOCK(rdch);
656: chn_setblocksize(rdch, 2, *arg_i);
657: CHN_UNLOCK(rdch);
658: }
659: break;
660:
661: case SNDCTL_DSP_RESET:
662: DEB(printf("dsp reset\n"));
663: if (wrch)
664: chn_abort(wrch);
665: if (rdch)
666: chn_abort(rdch);
667: break;
668:
669: case SNDCTL_DSP_SYNC:
670: DEB(printf("dsp sync\n"));
671: /* chn_sync may sleep */
672: if (wrch) {
673: CHN_LOCK(wrch);
674: chn_sync(wrch, sndbuf_getsize(wrch->bufsoft) - 4);
675: CHN_UNLOCK(wrch);
676: }
677: break;
678:
679: case SNDCTL_DSP_SPEED:
680: /* chn_setspeed may sleep */
681: tmp = 0;
682: if (wrch) {
683: CHN_LOCK(wrch);
684: ret = chn_setspeed(wrch, *arg_i);
685: tmp = wrch->speed;
686: CHN_UNLOCK(wrch);
687: }
688: if (rdch && ret == 0) {
689: CHN_LOCK(rdch);
690: ret = chn_setspeed(rdch, *arg_i);
691: if (tmp == 0)
692: tmp = rdch->speed;
693: CHN_UNLOCK(rdch);
694: }
695: *arg_i = tmp;
696: break;
697:
698: case SOUND_PCM_READ_RATE:
699: *arg_i = wrch? wrch->speed : rdch->speed;
700: break;
701:
702: case SNDCTL_DSP_STEREO:
703: tmp = -1;
704: *arg_i = (*arg_i)? AFMT_STEREO : 0;
705: if (wrch) {
706: CHN_LOCK(wrch);
707: ret = chn_setformat(wrch, (wrch->format & ~AFMT_STEREO) | *arg_i);
708: tmp = (wrch->format & AFMT_STEREO)? 1 : 0;
709: CHN_UNLOCK(wrch);
710: }
711: if (rdch && ret == 0) {
712: CHN_LOCK(rdch);
713: ret = chn_setformat(rdch, (rdch->format & ~AFMT_STEREO) | *arg_i);
714: if (tmp == -1)
715: tmp = (rdch->format & AFMT_STEREO)? 1 : 0;
716: CHN_UNLOCK(rdch);
717: }
718: *arg_i = tmp;
719: break;
720:
721: case SOUND_PCM_WRITE_CHANNELS:
722: /* case SNDCTL_DSP_CHANNELS: ( == SOUND_PCM_WRITE_CHANNELS) */
723: if (*arg_i != 0) {
724: tmp = 0;
725: *arg_i = (*arg_i != 1)? AFMT_STEREO : 0;
726: if (wrch) {
727: CHN_LOCK(wrch);
728: ret = chn_setformat(wrch, (wrch->format & ~AFMT_STEREO) | *arg_i);
729: tmp = (wrch->format & AFMT_STEREO)? 2 : 1;
730: CHN_UNLOCK(wrch);
731: }
732: if (rdch && ret == 0) {
733: CHN_LOCK(rdch);
734: ret = chn_setformat(rdch, (rdch->format & ~AFMT_STEREO) | *arg_i);
735: if (tmp == 0)
736: tmp = (rdch->format & AFMT_STEREO)? 2 : 1;
737: CHN_UNLOCK(rdch);
738: }
739: *arg_i = tmp;
740: } else {
741: *arg_i = ((wrch? wrch->format : rdch->format) & AFMT_STEREO)? 2 : 1;
742: }
743: break;
744:
745: case SOUND_PCM_READ_CHANNELS:
746: *arg_i = ((wrch? wrch->format : rdch->format) & AFMT_STEREO)? 2 : 1;
747: break;
748:
749: case SNDCTL_DSP_GETFMTS: /* returns a mask of supported fmts */
750: *arg_i = wrch? chn_getformats(wrch) : chn_getformats(rdch);
751: break ;
752:
753: case SNDCTL_DSP_SETFMT: /* sets _one_ format */
754: /* XXX locking */
755: if ((*arg_i != AFMT_QUERY)) {
756: tmp = 0;
757: if (wrch) {
758: CHN_LOCK(wrch);
759: ret = chn_setformat(wrch, (*arg_i) | (wrch->format & AFMT_STEREO));
760: tmp = wrch->format & ~AFMT_STEREO;
761: CHN_UNLOCK(wrch);
762: }
763: if (rdch && ret == 0) {
764: CHN_LOCK(rdch);
765: ret = chn_setformat(rdch, (*arg_i) | (rdch->format & AFMT_STEREO));
766: if (tmp == 0)
767: tmp = rdch->format & ~AFMT_STEREO;
768: CHN_UNLOCK(rdch);
769: }
770: *arg_i = tmp;
771: } else
772: *arg_i = (wrch? wrch->format : rdch->format) & ~AFMT_STEREO;
773: break;
774:
775: case SNDCTL_DSP_SETFRAGMENT:
776: /* XXX locking */
777: DEB(printf("SNDCTL_DSP_SETFRAGMENT 0x%08x\n", *(int *)arg));
778: {
779: u_int32_t fragln = (*arg_i) & 0x0000ffff;
780: u_int32_t maxfrags = ((*arg_i) & 0xffff0000) >> 16;
781: u_int32_t fragsz;
782:
783: RANGE(fragln, 4, 16);
784: fragsz = 1 << fragln;
785:
786: if (maxfrags == 0)
787: maxfrags = CHN_2NDBUFMAXSIZE / fragsz;
788: if (maxfrags < 2) {
789: ret = EINVAL;
790: break;
791: }
792: if (maxfrags * fragsz > CHN_2NDBUFMAXSIZE)
793: maxfrags = CHN_2NDBUFMAXSIZE / fragsz;
794:
795: DEB(printf("SNDCTL_DSP_SETFRAGMENT %d frags, %d sz\n", maxfrags, fragsz));
796: if (rdch) {
797: CHN_LOCK(rdch);
798: ret = chn_setblocksize(rdch, maxfrags, fragsz);
799: maxfrags = sndbuf_getblkcnt(rdch->bufsoft);
800: fragsz = sndbuf_getblksz(rdch->bufsoft);
801: CHN_UNLOCK(rdch);
802: }
803: if (wrch && ret == 0) {
804: CHN_LOCK(wrch);
805: ret = chn_setblocksize(wrch, maxfrags, fragsz);
806: maxfrags = sndbuf_getblkcnt(wrch->bufsoft);
807: fragsz = sndbuf_getblksz(wrch->bufsoft);
808: CHN_UNLOCK(wrch);
809: }
810:
811: fragln = 0;
812: while (fragsz > 1) {
813: fragln++;
814: fragsz >>= 1;
815: }
816: *arg_i = (maxfrags << 16) | fragln;
817: }
818: break;
819:
820: case SNDCTL_DSP_GETISPACE:
821: /* return the size of data available in the input queue */
822: {
823: audio_buf_info *a = (audio_buf_info *)arg;
824: if (rdch) {
825: struct snd_dbuf *bs = rdch->bufsoft;
826:
827: CHN_LOCK(rdch);
828: a->bytes = sndbuf_getready(bs);
829: a->fragments = a->bytes / sndbuf_getblksz(bs);
830: a->fragstotal = sndbuf_getblkcnt(bs);
831: a->fragsize = sndbuf_getblksz(bs);
832: CHN_UNLOCK(rdch);
833: }
834: }
835: break;
836:
837: case SNDCTL_DSP_GETOSPACE:
838: /* return space available in the output queue */
839: {
840: audio_buf_info *a = (audio_buf_info *)arg;
841: if (wrch) {
842: struct snd_dbuf *bs = wrch->bufsoft;
843:
844: CHN_LOCK(wrch);
845: chn_wrupdate(wrch);
846: a->bytes = sndbuf_getfree(bs);
847: a->fragments = a->bytes / sndbuf_getblksz(bs);
848: a->fragstotal = sndbuf_getblkcnt(bs);
849: a->fragsize = sndbuf_getblksz(bs);
850: CHN_UNLOCK(wrch);
851: }
852: }
853: break;
854:
855: case SNDCTL_DSP_GETIPTR:
856: {
857: count_info *a = (count_info *)arg;
858: if (rdch) {
859: struct snd_dbuf *bs = rdch->bufsoft;
860:
861: CHN_LOCK(rdch);
862: chn_rdupdate(rdch);
863: a->bytes = sndbuf_gettotal(bs);
864: a->blocks = sndbuf_getblocks(bs) - rdch->blocks;
865: a->ptr = sndbuf_getreadyptr(bs);
866: rdch->blocks = sndbuf_getblocks(bs);
867: CHN_UNLOCK(rdch);
868: } else
869: ret = EINVAL;
870: }
871: break;
872:
873: case SNDCTL_DSP_GETOPTR:
874: {
875: count_info *a = (count_info *)arg;
876: if (wrch) {
877: struct snd_dbuf *bs = wrch->bufsoft;
878:
879: CHN_LOCK(wrch);
880: chn_wrupdate(wrch);
881: a->bytes = sndbuf_gettotal(bs);
882: a->blocks = sndbuf_getblocks(bs) - wrch->blocks;
883: a->ptr = sndbuf_getreadyptr(bs);
884: wrch->blocks = sndbuf_getblocks(bs);
885: CHN_UNLOCK(wrch);
886: } else
887: ret = EINVAL;
888: }
889: break;
890:
891: case SNDCTL_DSP_GETCAPS:
892: *arg_i = DSP_CAP_REALTIME | DSP_CAP_MMAP | DSP_CAP_TRIGGER;
893: if (rdch && wrch && !(dsp_get_flags(i_dev) & SD_F_SIMPLEX))
894: *arg_i |= DSP_CAP_DUPLEX;
895: break;
896:
897: case SOUND_PCM_READ_BITS:
898: *arg_i = ((wrch? wrch->format : rdch->format) & AFMT_16BIT)? 16 : 8;
899: break;
900:
901: case SNDCTL_DSP_SETTRIGGER:
902: if (rdch) {
903: CHN_LOCK(rdch);
904: rdch->flags &= ~(CHN_F_TRIGGERED | CHN_F_NOTRIGGER);
905: if (*arg_i & PCM_ENABLE_INPUT)
906: chn_start(rdch, 1);
907: else
908: rdch->flags |= CHN_F_NOTRIGGER;
909: CHN_UNLOCK(rdch);
910: }
911: if (wrch) {
912: CHN_LOCK(wrch);
913: wrch->flags &= ~(CHN_F_TRIGGERED | CHN_F_NOTRIGGER);
914: if (*arg_i & PCM_ENABLE_OUTPUT)
915: chn_start(wrch, 1);
916: else
917: wrch->flags |= CHN_F_NOTRIGGER;
918: CHN_UNLOCK(wrch);
919: }
920: break;
921:
922: case SNDCTL_DSP_GETTRIGGER:
923: *arg_i = 0;
924: if (wrch && wrch->flags & CHN_F_TRIGGERED)
925: *arg_i |= PCM_ENABLE_OUTPUT;
926: if (rdch && rdch->flags & CHN_F_TRIGGERED)
927: *arg_i |= PCM_ENABLE_INPUT;
928: break;
929:
930: case SNDCTL_DSP_GETODELAY:
931: if (wrch) {
932: struct snd_dbuf *b = wrch->bufhard;
933: struct snd_dbuf *bs = wrch->bufsoft;
934:
935: CHN_LOCK(wrch);
936: chn_wrupdate(wrch);
937: *arg_i = sndbuf_getready(b) + sndbuf_getready(bs);
938: CHN_UNLOCK(wrch);
939: } else
940: ret = EINVAL;
941: break;
942:
943: case SNDCTL_DSP_POST:
944: if (wrch) {
945: CHN_LOCK(wrch);
946: wrch->flags &= ~CHN_F_NOTRIGGER;
947: chn_start(wrch, 1);
948: CHN_UNLOCK(wrch);
949: }
950: break;
951:
952: case SNDCTL_DSP_MAPINBUF:
953: case SNDCTL_DSP_MAPOUTBUF:
954: case SNDCTL_DSP_SETSYNCRO:
955: /* undocumented */
956:
957: case SNDCTL_DSP_SUBDIVIDE:
958: case SOUND_PCM_WRITE_FILTER:
959: case SOUND_PCM_READ_FILTER:
960: /* dunno what these do, don't sound important */
961: default:
962: DEB(printf("default ioctl fn 0x%08lx fail\n", cmd));
963: ret = EINVAL;
964: break;
965: }
966: relchns(i_dev, rdch, wrch, 0);
967: splx(s);
968: return ret;
969: }
970:
971: static int
972: dsp_poll(dev_t i_dev, int events, struct thread *td)
973: {
974: struct pcm_channel *wrch = NULL, *rdch = NULL;
975: intrmask_t s;
976: int ret, e;
977:
978: s = spltty();
979: ret = 0;
980: getchns(i_dev, &rdch, &wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
981:
982: if (wrch) {
983: e = (events & (POLLOUT | POLLWRNORM));
984: if (e)
985: ret |= chn_poll(wrch, e, td->td_proc);
986: }
987: if (rdch) {
988: e = (events & (POLLIN | POLLRDNORM));
989: if (e)
990: ret |= chn_poll(rdch, e, td->td_proc);
991: }
992: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
993:
994: splx(s);
995: return ret;
996: }
997:
998: static int
999: dsp_mmap(dev_t i_dev, vm_offset_t offset, int nprot)
1000: {
1001: struct pcm_channel *wrch = NULL, *rdch = NULL, *c;
1002: intrmask_t s;
1003: int ret;
1004:
1005: if (nprot & PROT_EXEC)
1006: return -1;
1007:
1008: s = spltty();
1009: getchns(i_dev, &rdch, &wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
1010: #if 0
1011: /*
1012: * XXX the linux api uses the nprot to select read/write buffer
1013: * our vm system doesn't allow this, so force write buffer
1014: */
1015:
1016: if (wrch && (nprot & PROT_WRITE)) {
1017: c = wrch;
1018: } else if (rdch && (nprot & PROT_READ)) {
1019: c = rdch;
1020: } else {
1021: splx(s);
1022: return -1;
1023: }
1024: #else
1025: c = wrch;
1026: #endif
1027:
1028: if (c == NULL) {
1029: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
1030: splx(s);
1031: return -1;
1032: }
1033:
1034: if (offset >= sndbuf_getsize(c->bufsoft)) {
1035: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
1036: splx(s);
1037: return -1;
1038: }
1039:
1040: if (!(c->flags & CHN_F_MAPPED))
1041: c->flags |= CHN_F_MAPPED;
1042:
1043: ret = atop(vtophys(sndbuf_getbufofs(c->bufsoft, offset)));
1044: relchns(i_dev, rdch, wrch, SD_F_PRIO_RD | SD_F_PRIO_WR);
1045:
1046: splx(s);
1047: return ret;
1048: }
1049:
1050: int
1051: dsp_register(int unit, int channel)
1052: {
1053: cdevsw_add(&dsp_cdevsw,
1054: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSP, 0));
1055: cdevsw_add(&dsp_cdevsw,
1056: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSP16, 0));
1057: cdevsw_add(&dsp_cdevsw,
1058: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_AUDIO, 0));
1059: cdevsw_add(&dsp_cdevsw,
1060: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_NORESET, 0));
1061: make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSP, channel),
1062: UID_ROOT, GID_WHEEL, 0666, "dsp%d.%d", unit, channel);
1063: make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSP16, channel),
1064: UID_ROOT, GID_WHEEL, 0666, "dspW%d.%d", unit, channel);
1065: make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_AUDIO, channel),
1066: UID_ROOT, GID_WHEEL, 0666, "audio%d.%d", unit, channel);
1067:
1068: return 0;
1069: }
1070:
1071: int
1072: dsp_registerrec(int unit, int channel)
1073: {
1074: cdevsw_add(&dsp_cdevsw,
1075: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSPREC, 0));
1076: make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSPREC, channel),
1077: UID_ROOT, GID_WHEEL, 0666, "dspr%d.%d", unit, channel);
1078:
1079: return 0;
1080: }
1081:
1082: int
1083: dsp_unregister(int unit, int channel)
1084: {
1085: cdevsw_remove(&dsp_cdevsw,
1086: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSP, 0));
1087: cdevsw_remove(&dsp_cdevsw,
1088: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSP16, 0));
1089: cdevsw_remove(&dsp_cdevsw,
1090: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_AUDIO, 0));
1091: cdevsw_remove(&dsp_cdevsw,
1092: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_NORESET, 0));
1093: return 0;
1094: }
1095:
1096: int
1097: dsp_unregisterrec(int unit, int channel)
1098: {
1099: cdevsw_remove(&dsp_cdevsw,
1100: PCMMKMINOR(-1, -1, 0), PCMMKMINOR(unit, SND_DEV_DSPREC, 0));
1101: return 0;
1102: }
1103:
1104: #ifdef USING_DEVFS
1105: static void
1106: dsp_clone(void *arg, char *name, int namelen, dev_t *dev)
1107: {
1108: dev_t pdev;
1109: int i, cont, unit, devtype;
1110: int devtypes[3] = {SND_DEV_DSP, SND_DEV_DSP16, SND_DEV_AUDIO};
1111: char *devnames[3] = {"dsp", "dspW", "audio"};
1112:
1113: if (*dev != NODEV)
1114: return;
1115: if (pcm_devclass == NULL)
1116: return;
1117:
1118: devtype = 0;
1119: unit = -1;
1120: for (i = 0; (i < 3) && (unit == -1); i++) {
1121: devtype = devtypes[i];
1122: if (strcmp(name, devnames[i]) == 0) {
1123: unit = snd_unit;
1124: } else {
1125: if (dev_stdclone(name, NULL, devnames[i], &unit) != 1)
1126: unit = -1;
1127: }
1128: }
1129: if (unit == -1 || unit >= devclass_get_maxunit(pcm_devclass))
1130: return;
1131:
1132: cont = 1;
1133: for (i = 0; cont; i++) {
1134: pdev = make_adhoc_dev(&dsp_cdevsw, PCMMKMINOR(unit, devtype, i));
1135: if (pdev->si_flags & SI_NAMED) {
1136: if ((pdev->si_drv1 == NULL) && (pdev->si_drv2 == NULL)) {
1137: *dev = pdev;
1138: return;
1139: }
1140: } else {
1141: cont = 0;
1142: }
1143: }
1144: }
1145:
1146: static void
1147: dsp_sysinit(void *p)
1148: {
1149: dsp_ehtag = EVENTHANDLER_REGISTER(dev_clone, dsp_clone, 0, 1000);
1150: }
1151:
1152: static void
1153: dsp_sysuninit(void *p)
1154: {
1155: if (dsp_ehtag != NULL)
1156: EVENTHANDLER_DEREGISTER(dev_clone, dsp_ehtag);
1157: }
1158:
1159: SYSINIT(dsp_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysinit, NULL);
1160: SYSUNINIT(dsp_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysuninit, NULL);
1161: #endif
1162:
1163:
![[BACK]](/icons//back.gif){kind=icon}
Return to dsp.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / dev / sound / pcm