4 * The DMA buffer manager for digitized voice applications
6 * Copyright by Hannu Savolainen 1993, 1994, 1995
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met: 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer. 2.
12 * Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * $FreeBSD: src/sys/i386/isa/sound/dmabuf.c,v 1.38.2.2 2000/08/08 19:49:54 peter Exp $
29 * $DragonFly: src/sys/dev/sound/isa/i386/Attic/dmabuf.c,v 1.3 2003/08/07 21:17:12 dillon Exp $
32 #include "sound_config.h"
34 #include <sys/select.h>
36 #include <machine/md_var.h>
38 #if defined(CONFIG_AUDIO) || defined(CONFIG_GUS)
42 DMAbuf_poll(int dev, struct fileinfo * file, int events, select_table * wait);
46 reorganize_buffers(int dev, struct dma_buffparms * dmap);
48 static int *in_sleeper[MAX_AUDIO_DEV] = {NULL};
49 static volatile struct snd_wait in_sleep_flag[MAX_AUDIO_DEV] = {{0}};
50 static int *out_sleeper[MAX_AUDIO_DEV] = {NULL};
51 static volatile struct snd_wait out_sleep_flag[MAX_AUDIO_DEV] = {{0}};
53 static int ndmaps = 0;
55 #define MAX_DMAP (MAX_AUDIO_DEV*2)
57 static struct dma_buffparms dmaps[MAX_DMAP] = {{0}};
59 * Primitive way to allocate such a large array. Needs dynamic run-time
63 static int space_in_queue(int dev);
65 static void dma_reset_output(int dev);
66 static void dma_reset_input(int dev);
69 reorganize_buffers(int dev, struct dma_buffparms * dmap)
72 * This routine breaks the physical device buffers to logical ones.
75 struct audio_operations *dsp_dev = audio_devs[dev];
79 if (dmap->fragment_size == 0) {
80 /* Compute the fragment size using the default algorithm */
82 sr = dsp_dev->ioctl(dev, SOUND_PCM_READ_RATE, 0, 1);
83 nc = dsp_dev->ioctl(dev, SOUND_PCM_READ_CHANNELS, 0, 1);
84 sz = dsp_dev->ioctl(dev, SOUND_PCM_READ_BITS, 0, 1);
87 dmap->neutral_byte = 254;
89 dmap->neutral_byte = 0x00;
91 if (sr < 1 || nc < 1 || sz < 1) {
92 printf("Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n",
94 sr = DSP_DEFAULT_SPEED;
100 sz /= 8; /* #bits -> #bytes */
103 * Compute a buffer size for time not exeeding 1 second.
104 * Usually this algorithm gives a buffer size for 0.5 to 1.0
105 * seconds of sound (using the current speed, sample size and
109 bsz = dsp_dev->buffsize;
113 if (bsz == dsp_dev->buffsize)
114 bsz /= 2; /* Needs at least 2 buffers */
116 if (dmap->subdivision == 0) /* Not already set */
117 dmap->subdivision = 1; /* Init to default value */
119 bsz /= dmap->subdivision;
122 bsz = 16; /* Just a sanity check */
124 dmap->fragment_size = bsz;
127 * The process has specified the buffer sice with
128 * SNDCTL_DSP_SETFRAGMENT or the buffer sice computation has
132 if (dmap->fragment_size > (audio_devs[dev]->buffsize / 2))
133 dmap->fragment_size = (audio_devs[dev]->buffsize / 2);
134 bsz = dmap->fragment_size;
137 bsz &= ~0x03; /* Force size which is multiple of 4 bytes */
138 #ifdef OS_DMA_ALIGN_CHECK
139 OS_DMA_ALIGN_CHECK(bsz);
142 n = dsp_dev->buffsize / bsz;
144 if (n > MAX_SUB_BUFFERS)
147 if (n > dmap->max_fragments)
148 n = dmap->max_fragments;
150 dmap->bytes_in_use = n * bsz;
152 for (i = 0; i < dmap->nbufs; i++) {
157 fillw (dmap->neutral_byte, dmap->raw_buf,
158 dmap->bytes_in_use/2);
160 dmap->flags |= DMA_ALLOC_DONE;
165 dma_init_buffers(int dev, struct dma_buffparms * dmap)
167 if (dmap == audio_devs[dev]->dmap_out) {
168 out_sleep_flag[dev].aborting = 0;
169 out_sleep_flag[dev].mode = WK_NONE;
171 in_sleep_flag[dev].aborting = 0;
172 in_sleep_flag[dev].mode = WK_NONE;
175 dmap->flags = DMA_BUSY; /* Other flags off */
176 dmap->qlen = dmap->qhead = dmap->qtail = 0;
178 dmap->bytes_in_use = audio_devs[dev]->buffsize;
180 dmap->dma_mode = DMODE_NONE;
181 dmap->mapping_flags = 0;
182 dmap->neutral_byte = 0x00;
186 open_dmap(int dev, int mode, struct dma_buffparms * dmap, int chan)
188 if (dmap->flags & DMA_BUSY)
191 #ifdef RUNTIME_DMA_ALLOC
195 if ((err = sound_alloc_dmap(dev, dmap, chan)) < 0)
200 if (dmap->raw_buf == NULL)
201 return -(ENOSPC); /* Memory allocation failed during boot */
204 printf("Unable to grab(2) DMA%d for the audio driver\n", chan);
207 dmap->open_mode = mode;
208 dmap->subdivision = dmap->underrun_count = 0;
209 dmap->fragment_size = 0;
210 dmap->max_fragments = 65536; /* Just a large value */
211 dmap->byte_counter = 0;
212 isa_dma_acquire(chan);
213 dmap->dma_chan = chan;
214 dma_init_buffers(dev, dmap);
220 close_dmap(int dev, struct dma_buffparms * dmap, int chan)
222 if (dmap->flags & DMA_BUSY)
223 dmap->dma_mode = DMODE_NONE;
224 dmap->flags &= ~DMA_BUSY;
225 isa_dma_release(dmap->dma_chan);
226 #ifdef RUNTIME_DMA_ALLOC
227 sound_free_dmap(dev, dmap);
232 DMAbuf_open(int dev, int mode)
235 struct dma_buffparms *dmap_in = NULL;
236 struct dma_buffparms *dmap_out = NULL;
238 if (dev >= num_audiodevs) {
239 printf("PCM device %d not installed.\n", dev);
242 if (!audio_devs[dev]) {
243 printf("PCM device %d not initialized\n", dev);
246 if (!(audio_devs[dev]->flags & DMA_DUPLEX)) {
247 audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
248 audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
250 if ((retval = audio_devs[dev]->open(dev, mode)) < 0)
253 dmap_out = audio_devs[dev]->dmap_out;
254 dmap_in = audio_devs[dev]->dmap_in;
256 if ((retval = open_dmap(dev, mode, dmap_out, audio_devs[dev]->dmachan1)) < 0) {
257 audio_devs[dev]->close(dev);
260 audio_devs[dev]->enable_bits = mode;
262 if (audio_devs[dev]->flags & DMA_DUPLEX && dmap_out != dmap_in) {
263 if ((retval = open_dmap(dev, mode, dmap_in, audio_devs[dev]->dmachan2)) < 0) {
264 audio_devs[dev]->close(dev);
265 close_dmap(dev, dmap_out, audio_devs[dev]->dmachan1);
269 audio_devs[dev]->open_mode = mode;
270 audio_devs[dev]->go = 1;
272 in_sleep_flag[dev].aborting = 0;
273 in_sleep_flag[dev].mode = WK_NONE;
275 out_sleep_flag[dev].aborting = 0;
276 out_sleep_flag[dev].mode = WK_NONE;
278 audio_devs[dev]->ioctl(dev, SOUND_PCM_WRITE_BITS, (ioctl_arg) 8, 1);
279 audio_devs[dev]->ioctl(dev, SOUND_PCM_WRITE_CHANNELS, (ioctl_arg) 1, 1);
280 audio_devs[dev]->ioctl(dev, SOUND_PCM_WRITE_RATE, (ioctl_arg) DSP_DEFAULT_SPEED, 1);
291 audio_devs[dev]->reset(dev);
294 dma_reset_output(dev);
296 if (audio_devs[dev]->flags & DMA_DUPLEX)
297 dma_reset_input(dev);
301 dma_reset_output(int dev)
306 if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
307 !audio_devs[dev]->halt_output)
308 audio_devs[dev]->reset(dev);
310 audio_devs[dev]->halt_output(dev);
313 dma_init_buffers(dev, audio_devs[dev]->dmap_out);
314 reorganize_buffers(dev, audio_devs[dev]->dmap_out);
318 dma_reset_input(int dev)
323 if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
324 !audio_devs[dev]->halt_input)
325 audio_devs[dev]->reset(dev);
327 audio_devs[dev]->halt_input(dev);
330 dma_init_buffers(dev, audio_devs[dev]->dmap_in);
331 reorganize_buffers(dev, audio_devs[dev]->dmap_in);
339 if (!audio_devs[dev]->go && (!audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT))
342 if (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT) {
345 out_sleep_flag[dev].aborting = 0;
346 #ifdef ALLOW_BUFFER_MAPPING
347 if(audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED &&
348 audio_devs[dev]->dmap_out->qlen) {
351 return audio_devs[dev]->dmap_out->qlen;
355 while (!PROCESS_ABORTING (out_sleep_flag[dev])
356 && audio_devs[dev]->dmap_out->qlen){
359 out_sleeper[dev] = &chn;
360 DO_SLEEP1(chn, out_sleep_flag[dev], 10 * hz);
361 if (TIMED_OUT (out_sleep_flag[dev]) ) {
365 return audio_devs[dev]->dmap_out->qlen;
374 * Some devices such as GUS have huge amount of on board RAM
375 * for the audio data. We have to wait until the device has
380 if (audio_devs[dev]->local_qlen) { /* Device has hidden buffers */
381 while (!(PROCESS_ABORTING (out_sleep_flag[dev]))
382 && audio_devs[dev]->local_qlen(dev)) {
384 out_sleeper[dev] = &chn;
385 DO_SLEEP(chn, out_sleep_flag[dev], 10 * hz);
391 return audio_devs[dev]->dmap_out->qlen;
395 DMAbuf_release(int dev, int mode)
399 if (!((out_sleep_flag[dev].aborting))
400 && (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT)) {
405 audio_devs[dev]->close(dev);
407 close_dmap(dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
409 if (audio_devs[dev]->flags & DMA_DUPLEX)
410 close_dmap(dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
411 audio_devs[dev]->open_mode = 0;
419 activate_recording(int dev, struct dma_buffparms * dmap)
421 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT))
424 if (dmap->flags & DMA_RESTART) {
425 dma_reset_input(dev);
426 dmap->flags &= ~DMA_RESTART;
428 if (dmap->dma_mode == DMODE_OUTPUT) { /* Direction change */
431 dmap->dma_mode = DMODE_NONE;
433 if (!(dmap->flags & DMA_ALLOC_DONE))
434 reorganize_buffers(dev, dmap);
436 if (!dmap->dma_mode) {
439 if ((err = audio_devs[dev]->prepare_for_input(dev,
440 dmap->fragment_size, dmap->nbufs)) < 0) {
443 dmap->dma_mode = DMODE_INPUT;
445 if (!(dmap->flags & DMA_ACTIVE)) {
446 audio_devs[dev]->start_input(dev,
447 dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
448 dmap->fragment_size, 0,
449 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
450 !(dmap->flags & DMA_STARTED));
451 dmap->flags |= DMA_ACTIVE | DMA_STARTED;
452 if (audio_devs[dev]->trigger)
453 audio_devs[dev]->trigger(dev,
454 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
460 DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
464 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
467 #ifdef ALLOW_BUFFER_MAPPING
468 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
469 printf("Sound: Can't read from mmapped device (1)\n");
476 if ((err = activate_recording(dev, dmap)) < 0) {
480 /* Wait for the next block */
486 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT) &
487 audio_devs[dev]->go) {
491 if (!audio_devs[dev]->go)
499 in_sleeper[dev] = &chn;
500 DO_SLEEP(chn, in_sleep_flag[dev], timeout);
503 /* XXX note -- nobody seems to set the mode to WK_TIMEOUT - lr */
504 if ((in_sleep_flag[dev].mode & WK_TIMEOUT)) {
505 /* XXX hey, we are in splhigh here ? lr 970705 */
506 printf("Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
508 audio_devs[dev]->reset(dev);
509 in_sleep_flag[dev].aborting = 1;
518 *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
519 *len = dmap->fragment_size - dmap->counts[dmap->qhead];
525 DMAbuf_rmchars(int dev, int buff_no, int c)
527 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
529 int p = dmap->counts[dmap->qhead] + c;
531 #ifdef ALLOW_BUFFER_MAPPING
532 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
533 printf("Sound: Can't read from mmapped device (2)\n");
537 if (p >= dmap->fragment_size) { /* This buffer is completely empty */
538 dmap->counts[dmap->qhead] = 0;
539 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
540 printf("\nSound: Audio queue1 corrupted for dev%d (%d/%d)\n",
541 dev, dmap->qlen, dmap->nbufs);
543 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
545 dmap->counts[dmap->qhead] = p;
551 dma_subdivide(int dev, struct dma_buffparms * dmap, ioctl_arg arg, int fact)
554 fact = dmap->subdivision;
557 return *(int *) arg = fact;
559 if (dmap->subdivision != 0 || dmap->fragment_size)/* Loo late to change */
562 if (fact > MAX_REALTIME_FACTOR)
565 if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
568 dmap->subdivision = fact;
569 return *(int *) arg = fact;
573 dma_set_fragment(int dev, struct dma_buffparms * dmap, ioctl_arg arg, int fact)
580 if (dmap->subdivision != 0 || dmap->fragment_size)/* Loo late to change */
583 bytes = fact & 0xffff;
584 count = (fact >> 16) & 0xffff;
587 count = MAX_SUB_BUFFERS;
590 if (bytes < 4 || bytes > 17) /* <16 || > 128k */
597 #ifdef OS_DMA_MINBITS
598 if (bytes < OS_DMA_MINBITS)
599 bytes = OS_DMA_MINBITS;
602 dmap->fragment_size = (1 << bytes);
604 dmap->max_fragments = count;
606 if (dmap->fragment_size > audio_devs[dev]->buffsize)
607 dmap->fragment_size = audio_devs[dev]->buffsize;
609 if (dmap->fragment_size == audio_devs[dev]->buffsize &&
610 audio_devs[dev]->flags & DMA_AUTOMODE)
611 dmap->fragment_size /= 2; /* Needs at least 2 buffers */
613 dmap->subdivision = 1; /* Disable SNDCTL_DSP_SUBDIVIDE */
614 return *(int *) arg = bytes | (count << 16);
618 get_buffer_pointer(int dev, int chan, struct dma_buffparms * dmap)
625 if (!(dmap->flags & DMA_ACTIVE))
629 pos = isa_dmastatus(chan);
634 pos = dmap->bytes_in_use - pos ;
635 if (audio_devs[dev]->flags & DMA_AUTOMODE)
639 pos = dmap->fragment_size - pos;
649 DMAbuf_ioctl(int dev, u_int cmd, ioctl_arg arg, int local)
651 struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
652 struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
657 case SNDCTL_DSP_RESET:
662 case SNDCTL_DSP_SYNC:
668 case SNDCTL_DSP_GETBLKSIZE:
669 if (!(dmap_out->flags & DMA_ALLOC_DONE))
670 reorganize_buffers(dev, dmap_out);
672 return *(int *) arg = dmap_out->fragment_size;
675 case SNDCTL_DSP_SETBLKSIZE:
677 int size = (*(int *) arg);
679 if (!(dmap_out->flags & DMA_ALLOC_DONE) && size) {
680 if ((size >> 16) > 0 )
681 dmap_out->fragment_size = size >> 16;
683 dmap_out->fragment_size = size;
685 dmap_out->max_fragments = 8888;
689 if (audio_devs[dev]->flags & DMA_DUPLEX) {
690 dmap_in->fragment_size = size;
691 dmap_in->max_fragments = 8888;
696 return -(EINVAL); /* Too late to change */
701 case SNDCTL_DSP_SUBDIVIDE:
703 int fact = (*(int *) arg);
706 ret = dma_subdivide(dev, dmap_out, arg, fact);
710 if (audio_devs[dev]->flags & DMA_DUPLEX)
711 ret = dma_subdivide(dev, dmap_in, arg, fact);
717 case SNDCTL_DSP_SETFRAGMENT:
719 int fact = (*(int *) arg);
722 ret = dma_set_fragment(dev, dmap_out, arg, fact);
726 if (audio_devs[dev]->flags & DMA_DUPLEX)
727 ret = dma_set_fragment(dev, dmap_in, arg, fact);
733 case SNDCTL_DSP_GETISPACE:
734 case SNDCTL_DSP_GETOSPACE:
738 struct dma_buffparms *dmap = dmap_out;
740 audio_buf_info *info = (audio_buf_info *) arg;
742 if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
745 #ifdef ALLOW_BUFFER_MAPPING
746 if (dmap->mapping_flags & DMA_MAP_MAPPED)
750 if (!(dmap->flags & DMA_ALLOC_DONE))
751 reorganize_buffers(dev, dmap);
753 info->fragstotal = dmap->nbufs;
755 if (cmd == SNDCTL_DSP_GETISPACE)
756 info->fragments = dmap->qlen;
758 if (!space_in_queue(dev))
761 info->fragments = dmap->nbufs - dmap->qlen;
762 if (audio_devs[dev]->local_qlen) {
763 int tmp = audio_devs[dev]->local_qlen(dev);
765 if (tmp & info->fragments)
766 tmp--; /* This buffer has been counted twice */
767 info->fragments -= tmp;
772 if (info->fragments < 0)
774 else if (info->fragments > dmap->nbufs)
775 info->fragments = dmap->nbufs;
777 info->fragsize = dmap->fragment_size;
778 info->bytes = info->fragments * dmap->fragment_size;
780 if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
781 info->bytes -= dmap->counts[dmap->qhead];
785 case SNDCTL_DSP_SETTRIGGER:
789 int bits = (*(int *) arg) & audio_devs[dev]->open_mode;
792 if (audio_devs[dev]->trigger == NULL)
795 if (!(audio_devs[dev]->flags & DMA_DUPLEX))
796 if ((bits & PCM_ENABLE_INPUT) && (bits & PCM_ENABLE_OUTPUT)) {
797 printf("Sound: Device doesn't have full duplex capability\n");
801 changed = audio_devs[dev]->enable_bits ^ bits;
803 if ((changed & bits) & PCM_ENABLE_INPUT && audio_devs[dev]->go) {
804 if (!(dmap_in->flags & DMA_ALLOC_DONE))
805 reorganize_buffers(dev, dmap_in);
806 activate_recording(dev, dmap_in);
808 #ifdef ALLOW_BUFFER_MAPPING
809 if ((changed & bits) & PCM_ENABLE_OUTPUT &&
810 dmap_out->mapping_flags & DMA_MAP_MAPPED &&
811 audio_devs[dev]->go) {
812 if (!(dmap_out->flags & DMA_ALLOC_DONE))
813 reorganize_buffers(dev, dmap_out);
815 audio_devs[dev]->prepare_for_output (dev,
816 dmap_out->fragment_size, dmap_out->nbufs);
818 dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
819 DMAbuf_start_output(dev, 0, dmap_out->fragment_size);
820 dmap_out->dma_mode = DMODE_OUTPUT;
824 audio_devs[dev]->enable_bits = bits;
825 if (changed && audio_devs[dev]->trigger)
826 audio_devs[dev]->trigger(dev, bits * audio_devs[dev]->go);
829 case SNDCTL_DSP_GETTRIGGER:
830 return *(int *) arg = audio_devs[dev]->enable_bits;
833 case SNDCTL_DSP_SETSYNCRO:
835 if (!audio_devs[dev]->trigger)
838 audio_devs[dev]->trigger(dev, 0);
839 audio_devs[dev]->go = 0;
843 case SNDCTL_DSP_GETIPTR:
849 info.bytes = audio_devs[dev]->dmap_in->byte_counter;
850 info.ptr = get_buffer_pointer(dev, audio_devs[dev]->dmachan2, audio_devs[dev]->dmap_in);
851 info.blocks = audio_devs[dev]->dmap_in->qlen;
852 info.bytes += info.ptr;
854 bcopy((char *) &info, &(((char *) arg)[0]), sizeof(info));
856 #ifdef ALLOW_BUFFER_MAPPING
857 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
858 audio_devs[dev]->dmap_in->qlen = 0; /* Ack interrupts */
865 case SNDCTL_DSP_GETOPTR:
871 info.bytes = audio_devs[dev]->dmap_out->byte_counter;
872 info.ptr = get_buffer_pointer(dev, audio_devs[dev]->dmachan1, audio_devs[dev]->dmap_out);
873 info.blocks = audio_devs[dev]->dmap_out->qlen;
874 info.bytes += info.ptr;
875 bcopy((char *) &info, &(((char *) arg)[0]), sizeof(info));
877 #ifdef ALLOW_BUFFER_MAPPING
878 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
879 audio_devs[dev]->dmap_out->qlen = 0; /* Ack interrupts */
887 return audio_devs[dev]->ioctl(dev, cmd, arg, local);
892 * DMAbuf_start_devices() is called by the /dev/music driver to start one or
893 * more audio devices at desired moment.
897 DMAbuf_start_devices(u_int devmask)
901 for (dev = 0; dev < num_audiodevs; dev++)
902 if (devmask & (1 << dev))
903 if (audio_devs[dev]->open_mode != 0)
904 if (!audio_devs[dev]->go) {
905 /* OK to start the device */
906 audio_devs[dev]->go = 1;
908 if (audio_devs[dev]->trigger)
909 audio_devs[dev]->trigger(dev,
910 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
915 space_in_queue(int dev)
918 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
919 if (dmap->qlen >= dmap->nbufs) /* No space at all */
923 * Verify that there are no more pending buffers than the limit
924 * defined by the process.
927 max = dmap->max_fragments;
930 if (audio_devs[dev]->local_qlen) {
931 tmp = audio_devs[dev]->local_qlen(dev);
933 tmp--; /* This buffer has been counted twice */
943 DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
946 int abort, err = EIO;
947 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
949 #ifdef ALLOW_BUFFER_MAPPING
950 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED) {
951 printf("Sound: Can't write to mmapped device (3)\n");
956 if (dmap->dma_mode == DMODE_INPUT) { /* Direction change */
958 dmap->dma_mode = DMODE_NONE;
959 } else if (dmap->flags & DMA_RESTART) { /* Restart buffering */
961 dma_reset_output(dev);
963 dmap->flags &= ~DMA_RESTART;
965 if (!(dmap->flags & DMA_ALLOC_DONE))
966 reorganize_buffers(dev, dmap);
968 if (!dmap->dma_mode) {
971 dmap->dma_mode = DMODE_OUTPUT;
972 if ((err = audio_devs[dev]->prepare_for_output(dev,
973 dmap->fragment_size, dmap->nbufs)) < 0)
979 while (!space_in_queue(dev) && !abort) {
986 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT) &&
987 audio_devs[dev]->go) {
992 * Wait for free space
994 if (!audio_devs[dev]->go)
1002 out_sleep_flag[dev].mode = WK_SLEEP;
1003 out_sleeper[dev] = &chn;
1004 DO_SLEEP2(chn, out_sleep_flag[dev], timeout);
1006 if ((out_sleep_flag[dev].mode & WK_TIMEOUT)) {
1007 printf("Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
1010 out_sleep_flag[dev].aborting = 1;
1011 audio_devs[dev]->reset(dev);
1012 } else if ((out_sleep_flag[dev].aborting) ||
1021 if (!space_in_queue(dev)) {
1022 return -(err); /* Caught a signal ? */
1024 *buf = dmap->raw_buf + dmap->qtail * dmap->fragment_size;
1025 *size = dmap->fragment_size;
1026 dmap->counts[dmap->qtail] = 0;
1031 DMAbuf_start_output(int dev, int buff_no, int l)
1033 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1036 * Bypass buffering if using mmaped access
1039 #ifdef ALLOW_BUFFER_MAPPING
1040 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED) {
1041 l = dmap->fragment_size;
1042 dmap->counts[dmap->qtail] = l;
1043 dmap->flags &= ~DMA_RESTART;
1044 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1051 if (buff_no != dmap->qtail)
1052 printf("Sound warning: DMA buffers out of sync %d != %d\n", buff_no, dmap->qtail);
1055 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1056 printf("\nSound: Audio queue2 corrupted for dev%d (%d/%d)\n",
1057 dev, dmap->qlen, dmap->nbufs);
1059 dmap->counts[dmap->qtail] = l;
1061 if ((l != dmap->fragment_size) &&
1062 ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
1063 audio_devs[dev]->flags & NEEDS_RESTART))
1064 dmap->flags |= DMA_RESTART;
1066 dmap->flags &= ~DMA_RESTART;
1068 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1070 if (!(dmap->flags & DMA_ACTIVE)) {
1071 dmap->flags |= DMA_ACTIVE;
1072 audio_devs[dev]->output_block(dev, dmap->raw_buf_phys +
1073 dmap->qhead * dmap->fragment_size,
1074 dmap->counts[dmap->qhead], 0,
1075 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
1076 !(dmap->flags & DMA_STARTED));
1077 dmap->flags |= DMA_STARTED;
1078 if (audio_devs[dev]->trigger)
1079 audio_devs[dev]->trigger(dev,
1080 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1086 DMAbuf_start_dma(int dev, u_long physaddr, int count, int dma_mode)
1089 struct dma_buffparms *dmap;
1091 if (dma_mode == 1) {
1092 chan = audio_devs[dev]->dmachan1;
1093 dmap = audio_devs[dev]->dmap_out;
1096 chan = audio_devs[dev]->dmachan2;
1097 dmap = audio_devs[dev]->dmap_in;
1101 * The count must be one less than the actual size. This is handled
1105 #ifndef PSEUDO_DMA_AUTOINIT
1106 if (audio_devs[dev]->flags & DMA_AUTOMODE) {
1107 /* Auto restart mode. Transfer the whole buffer */
1108 isa_dmastart(ISADMA_RAW | ((dma_mode == 0) ? ISADMA_READ : ISADMA_WRITE),
1109 (caddr_t) (void *) (uintptr_t) dmap->raw_buf_phys,
1110 dmap->bytes_in_use, chan);
1115 isa_dmastart((dma_mode == 0) ? ISADMA_READ : ISADMA_WRITE,
1116 (caddr_t) (void *) (uintptr_t) physaddr, count, chan);
1127 * NOTE! This routine could be called several times.
1128 * XXX is it ok to make it run only the first time ? -- lr970710
1131 for (dev = 0; dev < num_audiodevs; dev++)
1132 if (audio_devs[dev]->dmap_out == NULL) {
1133 audio_devs[dev]->dmap_out =
1134 audio_devs[dev]->dmap_in = &dmaps[ndmaps++];
1136 if (audio_devs[dev]->flags & DMA_DUPLEX)
1137 audio_devs[dev]->dmap_in = &dmaps[ndmaps++];
1142 DMAbuf_outputintr(int dev, int event_type)
1145 * Event types: 0 = DMA transfer done. Device still has more data in
1146 * the local buffer. 1 = DMA transfer done. Device doesn't have local
1147 * buffer or it's empty now. 2 = No DMA transfer but the device has
1148 * now more space in its local buffer.
1152 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1153 dmap->byte_counter += dmap->counts[dmap->qhead];
1155 sound_dma_intr(dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1157 #ifdef ALLOW_BUFFER_MAPPING
1158 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1159 /* mmapped access */
1161 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1162 dmap->qlen++; /* Yes increment it (don't decrement) */
1163 dmap->flags &= ~DMA_ACTIVE;
1164 dmap->counts[dmap->qhead] = dmap->fragment_size;
1166 if (!(audio_devs[dev]->flags & DMA_AUTOMODE)) {
1167 audio_devs[dev]->output_block(dev, dmap->raw_buf_phys +
1168 dmap->qhead * dmap->fragment_size,
1169 dmap->counts[dmap->qhead], 1,
1170 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1171 if (audio_devs[dev]->trigger)
1172 audio_devs[dev]->trigger(dev,
1173 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1175 #ifdef PSEUDO_DMA_AUTOINIT
1177 DMAbuf_start_dma(dev, dmap->raw_buf_phys +
1178 dmap->qhead * dmap->fragment_size,
1179 dmap->counts[dmap->qhead], 1);
1182 dmap->flags |= DMA_ACTIVE;
1186 if (event_type != 2) {
1187 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs) {
1188 printf("\nSound: Audio queue3 corrupted for dev%d (%d/%d)\n",
1189 dev, dmap->qlen, dmap->nbufs);
1192 if (!(audio_devs[dev]->flags & DMA_DISABLE))
1193 isa_dmadone(0, 0, 0, audio_devs[dev]->dmachan1);
1196 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1197 dmap->flags &= ~DMA_ACTIVE;
1199 /* if (!(audio_devs[dev]->flags & NEEDS_RESTART)) */
1201 audio_devs[dev]->output_block(dev, dmap->raw_buf_phys +
1202 dmap->qhead * dmap->fragment_size,
1203 dmap->counts[dmap->qhead], 1,
1204 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1205 if (audio_devs[dev]->trigger)
1206 audio_devs[dev]->trigger(dev,
1207 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1210 #ifdef PSEUDO_DMA_AUTOINIT
1213 DMAbuf_start_dma(dev, dmap->raw_buf_phys +
1214 dmap->qhead * dmap->fragment_size,
1215 dmap->counts[dmap->qhead], 1);
1218 dmap->flags |= DMA_ACTIVE;
1219 } else if (event_type == 1) {
1220 dmap->underrun_count++;
1221 if ((audio_devs[dev]->flags & DMA_DUPLEX) &&
1222 audio_devs[dev]->halt_output)
1223 audio_devs[dev]->halt_output(dev);
1225 audio_devs[dev]->halt_xfer(dev);
1227 if ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
1228 audio_devs[dev]->flags & NEEDS_RESTART)
1229 dmap->flags |= DMA_RESTART;
1231 dmap->flags &= ~DMA_RESTART;
1233 } /* event_type != 2 */
1236 if ((out_sleep_flag[dev].mode & WK_SLEEP)) {
1237 out_sleep_flag[dev].mode = WK_WAKEUP;
1238 wakeup(out_sleeper[dev]);
1241 if(selinfo[dev].si_pid) {
1242 selwakeup(&selinfo[dev]);
1249 DMAbuf_inputintr(int dev)
1252 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
1254 dmap->byte_counter += dmap->fragment_size;
1257 sound_dma_intr(dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1259 if (!(audio_devs[dev]->flags & DMA_DISABLE))
1260 isa_dmadone(0, 0, 0, audio_devs[dev]->dmachan2);
1262 #ifdef ALLOW_BUFFER_MAPPING
1263 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1264 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1267 if (!(audio_devs[dev]->flags & NEEDS_RESTART)) {
1268 audio_devs[dev]->start_input(dev, dmap->raw_buf_phys +
1269 dmap->qtail * dmap->fragment_size,
1270 dmap->fragment_size, 1,
1271 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1272 if (audio_devs[dev]->trigger)
1273 audio_devs[dev]->trigger(dev,
1274 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1276 #ifdef PSEUDO_DMA_AUTOINIT
1278 DMAbuf_start_dma(dev, dmap->raw_buf_phys +
1279 dmap->qtail * dmap->fragment_size,
1280 dmap->counts[dmap->qtail], 0);
1284 dmap->flags |= DMA_ACTIVE;
1287 if (dmap->qlen == (dmap->nbufs - 1)) {
1288 /* printf ("Sound: Recording overrun\n"); */
1289 dmap->underrun_count++;
1290 if ((audio_devs[dev]->flags & DMA_DUPLEX) &&
1291 audio_devs[dev]->halt_input)
1292 audio_devs[dev]->halt_input(dev);
1294 audio_devs[dev]->halt_xfer(dev);
1296 dmap->flags &= ~DMA_ACTIVE;
1297 if (audio_devs[dev]->flags & DMA_AUTOMODE)
1298 dmap->flags |= DMA_RESTART;
1300 dmap->flags &= ~DMA_RESTART;
1303 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1304 printf("\nSound: Audio queue4 corrupted for dev%d (%d/%d)\n",
1305 dev, dmap->qlen, dmap->nbufs);
1306 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1308 /* if (!(audio_devs[dev]->flags & DMA_AUTOMODE)) */
1310 audio_devs[dev]->start_input(dev, dmap->raw_buf_phys +
1311 dmap->qtail * dmap->fragment_size,
1312 dmap->fragment_size, 1,
1313 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1314 if (audio_devs[dev]->trigger)
1315 audio_devs[dev]->trigger(dev,
1316 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1318 #ifdef PSEUDO_DMA_AUTOINIT
1321 DMAbuf_start_dma(dev, dmap->raw_buf_phys +
1322 dmap->qtail * dmap->fragment_size,
1323 dmap->counts[dmap->qtail], 0);
1327 dmap->flags |= DMA_ACTIVE;
1331 if ((in_sleep_flag[dev].mode & WK_SLEEP)) {
1332 in_sleep_flag[dev].mode = WK_WAKEUP;
1333 wakeup(in_sleeper[dev]);
1335 if (selinfo[dev].si_pid)
1336 selwakeup(&selinfo[dev]);
1341 DMAbuf_open_dma(int dev)
1347 if ((err = open_dmap(dev, OPEN_READWRITE, audio_devs[dev]->dmap_out,
1348 audio_devs[dev]->dmachan1)) < 0) {
1352 dma_init_buffers(dev, audio_devs[dev]->dmap_out);
1353 /* audio_devs[dev]->dmap_out->flags |= DMA_ALLOC_DONE; */
1354 audio_devs[dev]->dmap_out->fragment_size = audio_devs[dev]->buffsize;
1355 /* reorganize_buffers (dev, audio_devs[dev]->dmap_out); */
1357 if (audio_devs[dev]->flags & DMA_DUPLEX) {
1358 if ((err = open_dmap(dev, OPEN_READWRITE,
1359 audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2)) < 0) {
1360 printf("Unable to grab DMA%d for the audio driver\n",
1361 audio_devs[dev]->dmachan2);
1362 close_dmap(dev, audio_devs[dev]->dmap_out,
1363 audio_devs[dev]->dmachan1);
1367 dma_init_buffers(dev, audio_devs[dev]->dmap_in);
1368 /* audio_devs[dev]->dmap_in->flags |= DMA_ALLOC_DONE; */
1369 audio_devs[dev]->dmap_in->fragment_size = audio_devs[dev]->buffsize;
1370 /* reorganize_buffers (dev, audio_devs[dev]->dmap_in); */
1372 audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
1373 audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
1381 DMAbuf_close_dma(int dev)
1383 DMAbuf_reset_dma(dev);
1384 close_dmap(dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1386 if (audio_devs[dev]->flags & DMA_DUPLEX)
1387 close_dmap(dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1392 DMAbuf_reset_dma(int dev)
1399 DMAbuf_poll(int dev, struct fileinfo * file, int events, select_table * wait)
1401 struct dma_buffparms *dmap;
1405 dmap = audio_devs[dev]->dmap_in;
1407 if (events & (POLLIN | POLLRDNORM)) {
1408 if (dmap->dma_mode != DMODE_INPUT) {
1409 if ((audio_devs[dev]->flags & DMA_DUPLEX) && !dmap->qlen &&
1410 audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT &&
1411 audio_devs[dev]->go) {
1416 activate_recording(dev, dmap);
1425 selrecord(wait, &selinfo[dev]);
1431 revents |= events & (POLLIN | POLLRDNORM);
1435 if (events & (POLLOUT | POLLWRNORM)) {
1437 dmap = audio_devs[dev]->dmap_out;
1438 if (dmap->dma_mode == DMODE_INPUT)
1441 if (dmap->dma_mode == DMODE_NONE)
1442 return ( events & (POLLOUT | POLLWRNORM));
1444 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1449 selrecord(wait, &selinfo[dev]);
1456 if (!space_in_queue(dev)) {
1458 selrecord(wait, &selinfo[dev]);
1462 revents |= events & (POLLOUT | POLLWRNORM);
1473 DMAbuf_select(int dev, struct fileinfo * file, int sel_type, select_table * wait)
1475 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1476 struct dma_buffparms *dmapin = audio_devs[dev]->dmap_in;
1481 if (dmapin->dma_mode != DMODE_INPUT)
1486 selrecord(wait, &selinfo[dev]);
1495 if (dmap->dma_mode == DMODE_INPUT)
1498 if (dmap->dma_mode == DMODE_NONE)
1501 if (!space_in_queue(dev)) {
1504 selrecord(wait, &selinfo[dev]);
1517 #endif /* ALLOW_POLL */
1520 #else /* CONFIG_AUDIO */
1522 * Stub versions if audio services not included
1526 DMAbuf_open(int dev, int mode)
1532 DMAbuf_release(int dev, int mode)
1538 DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
1544 DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
1550 DMAbuf_rmchars(int dev, int buff_no, int c)
1556 DMAbuf_start_output(int dev, int buff_no, int l)
1562 DMAbuf_ioctl(int dev, u_int cmd, ioctl_arg arg, int local)
1573 DMAbuf_start_dma(int dev, u_long physaddr, int count, int dma_mode)
1579 DMAbuf_open_dma(int dev)
1585 DMAbuf_close_dma(int dev)
1591 DMAbuf_reset_dma(int dev)
1597 DMAbuf_inputintr(int dev)
1603 DMAbuf_outputintr(int dev, int underrun_flag)
1607 #endif /* CONFIG_AUDIO */