Device layer rollup commit.
[dragonfly.git] / sys / dev / sound / pcm / dsp.c
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.6 2004/05/19 22:52:50 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.6 2004/05/19 22:52:50 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, PCMMKMINOR(-1, 0, 0), PCMMKMINOR(unit, 0, 0));
1054         make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSP, channel),
1055                  UID_ROOT, GID_WHEEL, 0666, "dsp%d.%d", unit, channel);
1056         make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSP16, channel),
1057                  UID_ROOT, GID_WHEEL, 0666, "dspW%d.%d", unit, channel);
1058         make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_AUDIO, channel),
1059                  UID_ROOT, GID_WHEEL, 0666, "audio%d.%d", unit, channel);
1060
1061         return 0;
1062 }
1063
1064 int
1065 dsp_registerrec(int unit, int channel)
1066 {
1067         make_dev(&dsp_cdevsw, PCMMKMINOR(unit, SND_DEV_DSPREC, channel),
1068                  UID_ROOT, GID_WHEEL, 0666, "dspr%d.%d", unit, channel);
1069
1070         return 0;
1071 }
1072
1073 int
1074 dsp_unregister(int unit, int channel)
1075 {
1076         cdevsw_remove(&dsp_cdevsw,
1077                         PCMMKMINOR(-1, 0, 0), PCMMKMINOR(unit, 0, 0));
1078         return 0;
1079 }
1080
1081 int
1082 dsp_unregisterrec(int unit, int channel)
1083 {
1084         return 0;
1085 }
1086
1087 #ifdef USING_DEVFS
1088 static void
1089 dsp_clone(void *arg, char *name, int namelen, dev_t *dev)
1090 {
1091         dev_t pdev;
1092         int i, cont, unit, devtype;
1093         int devtypes[3] = {SND_DEV_DSP, SND_DEV_DSP16, SND_DEV_AUDIO};
1094         char *devnames[3] = {"dsp", "dspW", "audio"};
1095
1096         if (*dev != NODEV)
1097                 return;
1098         if (pcm_devclass == NULL)
1099                 return;
1100
1101         devtype = 0;
1102         unit = -1;
1103         for (i = 0; (i < 3) && (unit == -1); i++) {
1104                 devtype = devtypes[i];
1105                 if (strcmp(name, devnames[i]) == 0) {
1106                         unit = snd_unit;
1107                 } else {
1108                         if (dev_stdclone(name, NULL, devnames[i], &unit) != 1)
1109                                 unit = -1;
1110                 }
1111         }
1112         if (unit == -1 || unit >= devclass_get_maxunit(pcm_devclass))
1113                 return;
1114
1115         cont = 1;
1116         for (i = 0; cont; i++) {
1117                 pdev = make_adhoc_dev(&dsp_cdevsw, PCMMKMINOR(unit, devtype, i));
1118                 if (pdev->si_flags & SI_NAMED) {
1119                         if ((pdev->si_drv1 == NULL) && (pdev->si_drv2 == NULL)) {
1120                                 *dev = pdev;
1121                                 return;
1122                         }
1123                 } else {
1124                         cont = 0;
1125                 }
1126         }
1127 }
1128
1129 static void
1130 dsp_sysinit(void *p)
1131 {
1132         dsp_ehtag = EVENTHANDLER_REGISTER(dev_clone, dsp_clone, 0, 1000);
1133 }
1134
1135 static void
1136 dsp_sysuninit(void *p)
1137 {
1138         if (dsp_ehtag != NULL)
1139                 EVENTHANDLER_DEREGISTER(dev_clone, dsp_ehtag);
1140 }
1141
1142 SYSINIT(dsp_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysinit, NULL);
1143 SYSUNINIT(dsp_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, dsp_sysuninit, NULL);
1144 #endif
1145
1146