This source file includes following definitions.
- reorganize_buffers
- dma_init_buffers
- open_dmap
- close_dmap
- DMAbuf_open
- dma_reset
- dma_reset_output
- dma_reset_input
- dma_sync
- DMAbuf_release
- activate_recording
- DMAbuf_getrdbuffer
- DMAbuf_rmchars
- dma_subdivide
- dma_set_fragment
- get_buffer_pointer
- DMAbuf_ioctl
- DMAbuf_start_devices
- space_in_queue
- DMAbuf_getwrbuffer
- DMAbuf_get_curr_buffer
- DMAbuf_set_count
- DMAbuf_start_output
- DMAbuf_start_dma
- DMAbuf_init
- DMAbuf_outputintr
- DMAbuf_inputintr
- DMAbuf_open_dma
- DMAbuf_close_dma
- DMAbuf_reset_dma
- DMAbuf_select
- DMAbuf_open
- DMAbuf_release
- DMAbuf_getwrbuffer
- DMAbuf_getrdbuffer
- DMAbuf_rmchars
- DMAbuf_start_output
- DMAbuf_ioctl
- DMAbuf_init
- DMAbuf_start_dma
- DMAbuf_open_dma
- DMAbuf_close_dma
- DMAbuf_reset_dma
- DMAbuf_inputintr
- DMAbuf_outputintr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29 #include <linux/config.h>
30
31
32 #include "sound_config.h"
33
34 #if defined(CONFIG_AUDIO) || defined(CONFIG_GUS)
35
36 static wait_handle *in_sleeper[MAX_AUDIO_DEV] =
37 {NULL};
38 static volatile struct snd_wait in_sleep_flag[MAX_AUDIO_DEV] =
39 {
40 {0}};
41 static wait_handle *out_sleeper[MAX_AUDIO_DEV] =
42 {NULL};
43 static volatile struct snd_wait out_sleep_flag[MAX_AUDIO_DEV] =
44 {
45 {0}};
46
47 static int ndmaps = 0;
48
49 #define MAX_DMAP (MAX_AUDIO_DEV*2)
50
51 static struct dma_buffparms dmaps[MAX_DMAP] =
52 {
53 {0}};
54
55
56
57
58
59 static int space_in_queue (int dev);
60
61 static void dma_reset_output (int dev);
62 static void dma_reset_input (int dev);
63
64 static void
65 reorganize_buffers (int dev, struct dma_buffparms *dmap)
66 {
67
68
69
70
71 struct audio_operations *dsp_dev = audio_devs[dev];
72
73 unsigned i, n;
74 unsigned sr, nc, sz, bsz;
75
76 if (dmap->fragment_size == 0)
77 {
78
79 sr = dsp_dev->ioctl (dev, SOUND_PCM_READ_RATE, 0, 1);
80 nc = dsp_dev->ioctl (dev, SOUND_PCM_READ_CHANNELS, 0, 1);
81 sz = dsp_dev->ioctl (dev, SOUND_PCM_READ_BITS, 0, 1);
82
83 if (sz == 8)
84 dmap->neutral_byte = 0x80;
85 else
86 dmap->neutral_byte = 0x00;
87
88 if (sr < 1 || nc < 1 || sz < 1)
89 {
90 printk ("Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n",
91 dev, sr, nc, sz);
92 sr = DSP_DEFAULT_SPEED;
93 nc = 1;
94 sz = 8;
95 }
96
97 sz = sr * nc * sz;
98
99 sz /= 8;
100
101
102
103
104
105
106
107 bsz = dsp_dev->buffsize;
108 while (bsz > sz)
109 bsz /= 2;
110
111 if (bsz == dsp_dev->buffsize)
112 bsz /= 2;
113
114
115
116
117
118
119
120 if (dmap->subdivision == 0)
121 #ifdef V35A9_COMPATIBLE
122 dmap->subdivision = 1;
123 #else
124 dmap->subdivision = 4;
125 #endif
126
127 bsz /= dmap->subdivision;
128
129 if (bsz < 16)
130 bsz = 16;
131
132 dmap->fragment_size = bsz;
133 }
134 else
135 {
136
137
138
139
140 if (dmap->fragment_size > (audio_devs[dev]->buffsize / 2))
141 dmap->fragment_size = (audio_devs[dev]->buffsize / 2);
142 bsz = dmap->fragment_size;
143 }
144
145 bsz &= ~0x03;
146 #ifdef OS_DMA_ALIGN_CHECK
147 OS_DMA_ALIGN_CHECK (bsz);
148 #endif
149
150 n = dsp_dev->buffsize / bsz;
151 if (n > MAX_SUB_BUFFERS)
152 n = MAX_SUB_BUFFERS;
153 if (n > dmap->max_fragments)
154 n = dmap->max_fragments;
155 dmap->nbufs = n;
156 dmap->bytes_in_use = n * bsz;
157
158 for (i = 0; i < dmap->nbufs; i++)
159 {
160 dmap->counts[i] = 0;
161 }
162
163 dmap->flags |= DMA_ALLOC_DONE;
164 }
165
166 static void
167 dma_init_buffers (int dev, struct dma_buffparms *dmap)
168 {
169 if (dmap == audio_devs[dev]->dmap_out)
170 {
171 out_sleep_flag[dev].mode = WK_NONE;
172 }
173 else
174 {
175 in_sleep_flag[dev].mode = WK_NONE;
176 }
177
178 dmap->flags = DMA_BUSY;
179 dmap->qlen = dmap->qhead = dmap->qtail = 0;
180 dmap->nbufs = 1;
181 dmap->bytes_in_use = audio_devs[dev]->buffsize;
182
183 dmap->dma_mode = DMODE_NONE;
184 dmap->mapping_flags = 0;
185 dmap->neutral_byte = 0x80;
186 dmap->cfrag = -1;
187 dmap->closing = 0;
188 }
189
190 static int
191 open_dmap (int dev, int mode, struct dma_buffparms *dmap, int chan)
192 {
193 if (dmap->flags & DMA_BUSY)
194 return -EBUSY;
195
196 {
197 int err;
198
199 if ((err = sound_alloc_dmap (dev, dmap, chan)) < 0)
200 return err;
201 }
202
203 if (dmap->raw_buf == NULL)
204 return -ENOSPC;
205
206 if (sound_open_dma (chan, audio_devs[dev]->name))
207 {
208 printk ("Unable to grab(2) DMA%d for the audio driver\n", chan);
209 return -EBUSY;
210 }
211
212 dmap->open_mode = mode;
213 dmap->subdivision = dmap->underrun_count = 0;
214 dmap->fragment_size = 0;
215 dmap->max_fragments = 65536;
216 dmap->byte_counter = 0;
217
218 dma_init_buffers (dev, dmap);
219
220 return 0;
221 }
222
223 static void
224 close_dmap (int dev, struct dma_buffparms *dmap, int chan)
225 {
226 sound_close_dma (chan);
227
228 if (dmap->flags & DMA_BUSY)
229 dmap->dma_mode = DMODE_NONE;
230 dmap->flags &= ~DMA_BUSY;
231
232 sound_free_dmap (dev, dmap);
233 }
234
235 int
236 DMAbuf_open (int dev, int mode)
237 {
238 int retval;
239 struct dma_buffparms *dmap_in = NULL;
240 struct dma_buffparms *dmap_out = NULL;
241
242 if (dev >= num_audiodevs)
243 {
244 printk ("PCM device %d not installed.\n", dev);
245 return -ENXIO;
246 }
247
248 if (!audio_devs[dev])
249 {
250 printk ("PCM device %d not initialized\n", dev);
251 return -ENXIO;
252 }
253
254 if (!(audio_devs[dev]->flags & DMA_DUPLEX))
255 {
256 audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
257 audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
258 }
259
260 if ((retval = audio_devs[dev]->open (dev, mode)) < 0)
261 return retval;
262
263 dmap_out = audio_devs[dev]->dmap_out;
264 dmap_in = audio_devs[dev]->dmap_in;
265
266 if ((retval = open_dmap (dev, mode, dmap_out, audio_devs[dev]->dmachan1)) < 0)
267 {
268 audio_devs[dev]->close (dev);
269 return retval;
270 }
271
272 audio_devs[dev]->enable_bits = mode;
273 if (audio_devs[dev]->flags & DMA_DUPLEX && dmap_out != dmap_in)
274 if ((retval = open_dmap (dev, mode, dmap_in, audio_devs[dev]->dmachan2)) < 0)
275 {
276 audio_devs[dev]->close (dev);
277 close_dmap (dev, dmap_out, audio_devs[dev]->dmachan1);
278 return retval;
279 }
280 audio_devs[dev]->open_mode = mode;
281 audio_devs[dev]->go = 1;
282 in_sleep_flag[dev].mode = WK_NONE;
283 out_sleep_flag[dev].mode = WK_NONE;
284
285 audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_BITS, (caddr_t) 8, 1);
286 audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_CHANNELS, (caddr_t) 1, 1);
287 audio_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_RATE, (caddr_t) DSP_DEFAULT_SPEED, 1);
288
289 return 0;
290 }
291
292 static void
293 dma_reset (int dev)
294 {
295 unsigned long flags;
296
297 save_flags (flags);
298 cli ();
299 audio_devs[dev]->reset (dev);
300 restore_flags (flags);
301
302 dma_reset_output (dev);
303
304 if (audio_devs[dev]->flags & DMA_DUPLEX)
305 dma_reset_input (dev);
306 }
307
308 static void
309 dma_reset_output (int dev)
310 {
311 unsigned long flags;
312
313 save_flags (flags);
314 cli ();
315 if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
316 !audio_devs[dev]->halt_output)
317 audio_devs[dev]->reset (dev);
318 else
319 audio_devs[dev]->halt_output (dev);
320 restore_flags (flags);
321
322 dma_init_buffers (dev, audio_devs[dev]->dmap_out);
323 reorganize_buffers (dev, audio_devs[dev]->dmap_out);
324 }
325
326 static void
327 dma_reset_input (int dev)
328 {
329 unsigned long flags;
330
331 save_flags (flags);
332 cli ();
333 if (!(audio_devs[dev]->flags & DMA_DUPLEX) ||
334 !audio_devs[dev]->halt_input)
335 audio_devs[dev]->reset (dev);
336 else
337 audio_devs[dev]->halt_input (dev);
338 restore_flags (flags);
339
340 dma_init_buffers (dev, audio_devs[dev]->dmap_in);
341 reorganize_buffers (dev, audio_devs[dev]->dmap_in);
342 }
343
344 static int
345 dma_sync (int dev)
346 {
347 unsigned long flags;
348
349 if (!audio_devs[dev]->go && (!audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT))
350 return 0;
351
352 if (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT)
353 {
354 save_flags (flags);
355 cli ();
356
357 while (!current_got_fatal_signal ()
358 && audio_devs[dev]->dmap_out->qlen)
359 {
360
361 {
362 unsigned long tl;
363
364 if (HZ)
365 current_set_timeout (tl = jiffies + (HZ));
366 else
367 tl = (unsigned long) -1;
368 out_sleep_flag[dev].mode = WK_SLEEP;
369 module_interruptible_sleep_on (&out_sleeper[dev]);
370 if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
371 {
372 if (jiffies >= tl)
373 out_sleep_flag[dev].mode |= WK_TIMEOUT;
374 }
375 out_sleep_flag[dev].mode &= ~WK_SLEEP;
376 };
377 if ((out_sleep_flag[dev].mode & WK_TIMEOUT))
378 {
379 restore_flags (flags);
380 return audio_devs[dev]->dmap_out->qlen;
381 }
382 }
383 restore_flags (flags);
384
385
386
387
388
389
390 save_flags (flags);
391 cli ();
392 if (audio_devs[dev]->local_qlen)
393 {
394 while (!(current_got_fatal_signal ())
395 && audio_devs[dev]->local_qlen (dev))
396 {
397
398 {
399 unsigned long tl;
400
401 if (HZ)
402 current_set_timeout (tl = jiffies + (HZ));
403 else
404 tl = (unsigned long) -1;
405 out_sleep_flag[dev].mode = WK_SLEEP;
406 module_interruptible_sleep_on (&out_sleeper[dev]);
407 if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
408 {
409 if (jiffies >= tl)
410 out_sleep_flag[dev].mode |= WK_TIMEOUT;
411 }
412 out_sleep_flag[dev].mode &= ~WK_SLEEP;
413 };
414 }
415 }
416 restore_flags (flags);
417 }
418 return audio_devs[dev]->dmap_out->qlen;
419 }
420
421 int
422 DMAbuf_release (int dev, int mode)
423 {
424 unsigned long flags;
425
426 audio_devs[dev]->dmap_out->closing = 1;
427 audio_devs[dev]->dmap_in->closing = 1;
428
429 if (!(current_got_fatal_signal ())
430 && (audio_devs[dev]->dmap_out->dma_mode == DMODE_OUTPUT))
431 {
432 dma_sync (dev);
433
434 memset (audio_devs[dev]->dmap_out->raw_buf,
435 audio_devs[dev]->dmap_out->neutral_byte,
436 audio_devs[dev]->dmap_out->bytes_in_use);
437 }
438
439 save_flags (flags);
440 cli ();
441
442 audio_devs[dev]->close (dev);
443
444 close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
445
446 if (audio_devs[dev]->flags & DMA_DUPLEX)
447 close_dmap (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
448 audio_devs[dev]->open_mode = 0;
449
450 restore_flags (flags);
451
452 return 0;
453 }
454
455 static int
456 activate_recording (int dev, struct dma_buffparms *dmap)
457 {
458 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT))
459 return 0;
460
461 if (dmap->flags & DMA_RESTART)
462 {
463 dma_reset_input (dev);
464 dmap->flags &= ~DMA_RESTART;
465 }
466
467 if (dmap->dma_mode == DMODE_OUTPUT)
468 {
469 dma_sync (dev);
470 dma_reset (dev);
471 dmap->dma_mode = DMODE_NONE;
472 }
473
474 if (!(dmap->flags & DMA_ALLOC_DONE))
475 reorganize_buffers (dev, dmap);
476
477 if (!dmap->dma_mode)
478 {
479 int err;
480
481 if ((err = audio_devs[dev]->prepare_for_input (dev,
482 dmap->fragment_size, dmap->nbufs)) < 0)
483 {
484 return err;
485 }
486 dmap->dma_mode = DMODE_INPUT;
487 }
488
489 if (!(dmap->flags & DMA_ACTIVE))
490 {
491 audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
492 dmap->qtail * dmap->fragment_size,
493 dmap->fragment_size, 0,
494 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
495 !(dmap->flags & DMA_STARTED));
496 dmap->flags |= DMA_ACTIVE | DMA_STARTED;
497 if (audio_devs[dev]->trigger)
498 audio_devs[dev]->trigger (dev,
499 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
500 }
501 return 0;
502 }
503
504 int
505 DMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
506 {
507 unsigned long flags;
508 int err = EIO;
509 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
510
511 save_flags (flags);
512 cli ();
513 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
514 {
515 printk ("Sound: Can't read from mmapped device (1)\n");
516 return -EINVAL;
517 }
518 else if (!dmap->qlen)
519 {
520 int timeout;
521
522 if ((err = activate_recording (dev, dmap)) < 0)
523 {
524 restore_flags (flags);
525 return err;
526 }
527
528
529
530 if (dontblock)
531 {
532 restore_flags (flags);
533 return -EAGAIN;
534 }
535
536 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT) &
537 audio_devs[dev]->go)
538 {
539 restore_flags (flags);
540 return -EAGAIN;
541 }
542
543 if (!audio_devs[dev]->go)
544 timeout = 0;
545 else
546 timeout = 2 * HZ;
547
548
549 {
550 unsigned long tl;
551
552 if (timeout)
553 current_set_timeout (tl = jiffies + (timeout));
554 else
555 tl = (unsigned long) -1;
556 in_sleep_flag[dev].mode = WK_SLEEP;
557 module_interruptible_sleep_on (&in_sleeper[dev]);
558 if (!(in_sleep_flag[dev].mode & WK_WAKEUP))
559 {
560 if (jiffies >= tl)
561 in_sleep_flag[dev].mode |= WK_TIMEOUT;
562 }
563 in_sleep_flag[dev].mode &= ~WK_SLEEP;
564 };
565 if ((in_sleep_flag[dev].mode & WK_TIMEOUT))
566 {
567 printk ("Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
568 err = EIO;
569 audio_devs[dev]->reset (dev);
570 ;
571 }
572 else
573 err = EINTR;
574 }
575 restore_flags (flags);
576
577 if (!dmap->qlen)
578 return -err;
579
580 *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
581 *len = dmap->fragment_size - dmap->counts[dmap->qhead];
582
583 return dmap->qhead;
584 }
585
586 int
587 DMAbuf_rmchars (int dev, int buff_no, int c)
588 {
589 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
590
591 int p = dmap->counts[dmap->qhead] + c;
592
593 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
594 {
595 printk ("Sound: Can't read from mmapped device (2)\n");
596 return -EINVAL;
597 }
598 else if (p >= dmap->fragment_size)
599 {
600 dmap->counts[dmap->qhead] = 0;
601 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
602 printk ("\nSound: Audio queue1 corrupted for dev%d (%d/%d)\n",
603 dev, dmap->qlen, dmap->nbufs);
604 dmap->qlen--;
605 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
606 }
607 else
608 dmap->counts[dmap->qhead] = p;
609
610 return 0;
611 }
612
613 static int
614 dma_subdivide (int dev, struct dma_buffparms *dmap, caddr_t arg, int fact)
615 {
616 if (fact == 0)
617 {
618 fact = dmap->subdivision;
619 if (fact == 0)
620 fact = 1;
621 return snd_ioctl_return ((int *) arg, fact);
622 }
623
624 if (dmap->subdivision != 0 ||
625 dmap->fragment_size)
626 return -EINVAL;
627
628 if (fact > MAX_REALTIME_FACTOR)
629 return -EINVAL;
630
631 if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
632 return -EINVAL;
633
634 dmap->subdivision = fact;
635 return snd_ioctl_return ((int *) arg, fact);
636 }
637
638 static int
639 dma_set_fragment (int dev, struct dma_buffparms *dmap, caddr_t arg, int fact)
640 {
641 int bytes, count;
642
643 if (fact == 0)
644 return -EIO;
645
646 if (dmap->subdivision != 0 ||
647 dmap->fragment_size)
648 return -EINVAL;
649
650 bytes = fact & 0xffff;
651 count = (fact >> 16) & 0xffff;
652
653 if (count == 0)
654 count = MAX_SUB_BUFFERS;
655
656 if (bytes < 4 || bytes > 17)
657 return -EINVAL;
658
659 if (count < 2)
660 return -EINVAL;
661
662 #ifdef OS_DMA_MINBITS
663 if (bytes < OS_DMA_MINBITS)
664 bytes = OS_DMA_MINBITS;
665 #endif
666
667 dmap->fragment_size = (1 << bytes);
668 dmap->max_fragments = count;
669
670 if (dmap->fragment_size > audio_devs[dev]->buffsize)
671 dmap->fragment_size = audio_devs[dev]->buffsize;
672
673 if (dmap->fragment_size == audio_devs[dev]->buffsize &&
674 audio_devs[dev]->flags & DMA_AUTOMODE)
675 dmap->fragment_size /= 2;
676
677 dmap->subdivision = 1;
678 return snd_ioctl_return ((int *) arg, bytes | (count << 16));
679 }
680
681 static int
682 get_buffer_pointer (int dev, int chan, struct dma_buffparms *dmap)
683 {
684 int pos;
685 unsigned long flags;
686
687 save_flags (flags);
688 cli ();
689 if (!(dmap->flags & DMA_ACTIVE))
690 pos = 0;
691 else
692 {
693 clear_dma_ff (chan);
694 disable_dma (chan);
695 pos = get_dma_residue (chan);
696 enable_dma (chan);
697 }
698 restore_flags (flags);
699
700
701 if (audio_devs[dev]->flags & DMA_AUTOMODE)
702 return dmap->bytes_in_use - pos;
703 else
704 {
705 pos = dmap->fragment_size - pos;
706 if (pos < 0)
707 return 0;
708 return pos;
709 }
710 }
711
712 int
713 DMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
714 {
715 struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
716 struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
717
718 switch (cmd)
719 {
720 case SNDCTL_DSP_RESET:
721 dma_reset (dev);
722 return 0;
723 break;
724
725 case SNDCTL_DSP_SYNC:
726 dma_sync (dev);
727 dma_reset (dev);
728 return 0;
729 break;
730
731 case SNDCTL_DSP_GETBLKSIZE:
732 if (!(dmap_out->flags & DMA_ALLOC_DONE))
733 reorganize_buffers (dev, dmap_out);
734
735 return snd_ioctl_return ((int *) arg, dmap_out->fragment_size);
736 break;
737
738 case SNDCTL_DSP_SUBDIVIDE:
739 {
740 int fact = get_fs_long ((long *) arg);
741 int ret;
742
743 ret = dma_subdivide (dev, dmap_out, arg, fact);
744 if (ret < 0)
745 return ret;
746
747 if (audio_devs[dev]->flags & DMA_DUPLEX)
748 ret = dma_subdivide (dev, dmap_in, arg, fact);
749
750 return ret;
751 }
752 break;
753
754 case SNDCTL_DSP_SETFRAGMENT:
755 {
756 int fact = get_fs_long ((long *) arg);
757 int ret;
758
759 ret = dma_set_fragment (dev, dmap_out, arg, fact);
760 if (ret < 0)
761 return ret;
762
763 if (audio_devs[dev]->flags & DMA_DUPLEX)
764 ret = dma_set_fragment (dev, dmap_in, arg, fact);
765
766 return ret;
767 }
768 break;
769
770 case SNDCTL_DSP_GETISPACE:
771 case SNDCTL_DSP_GETOSPACE:
772 if (!local)
773 return -EINVAL;
774 else
775 {
776 struct dma_buffparms *dmap = dmap_out;
777
778 audio_buf_info *info = (audio_buf_info *) arg;
779
780 if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
781 dmap = dmap_in;
782
783 if (dmap->mapping_flags & DMA_MAP_MAPPED)
784 return -EINVAL;
785
786 if (!(dmap->flags & DMA_ALLOC_DONE))
787 reorganize_buffers (dev, dmap);
788
789 info->fragstotal = dmap->nbufs;
790
791 if (cmd == SNDCTL_DSP_GETISPACE)
792 info->fragments = dmap->qlen;
793 else
794 {
795 if (!space_in_queue (dev))
796 info->fragments = 0;
797 else
798 {
799 info->fragments = dmap->nbufs - dmap->qlen;
800 if (audio_devs[dev]->local_qlen)
801 {
802 int tmp = audio_devs[dev]->local_qlen (dev);
803
804 if (tmp && info->fragments)
805 tmp--;
806
807
808 info->fragments -= tmp;
809 }
810 }
811 }
812
813 if (info->fragments < 0)
814 info->fragments = 0;
815 else if (info->fragments > dmap->nbufs)
816 info->fragments = dmap->nbufs;
817
818 info->fragsize = dmap->fragment_size;
819 info->bytes = info->fragments * dmap->fragment_size;
820
821 if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
822 info->bytes -= dmap->counts[dmap->qhead];
823 }
824 return 0;
825
826 case SNDCTL_DSP_SETTRIGGER:
827 {
828 unsigned long flags;
829
830 int bits = get_fs_long ((long *) arg) & audio_devs[dev]->open_mode;
831 int changed;
832
833 if (audio_devs[dev]->trigger == NULL)
834 return -EINVAL;
835
836 if (!(audio_devs[dev]->flags & DMA_DUPLEX))
837 if ((bits & PCM_ENABLE_INPUT) && (bits & PCM_ENABLE_OUTPUT))
838 {
839 printk ("Sound: Device doesn't have full duplex capability\n");
840 return -EINVAL;
841 }
842
843 save_flags (flags);
844 cli ();
845 changed = audio_devs[dev]->enable_bits ^ bits;
846
847 if ((changed & bits) & PCM_ENABLE_INPUT && audio_devs[dev]->go)
848 {
849 if (!(dmap_in->flags & DMA_ALLOC_DONE))
850 reorganize_buffers (dev, dmap_in);
851
852 activate_recording (dev, dmap_in);
853 }
854
855 if ((changed & bits) & PCM_ENABLE_OUTPUT &&
856 dmap_out->mapping_flags & DMA_MAP_MAPPED &&
857 audio_devs[dev]->go)
858 {
859 if (!(dmap_out->flags & DMA_ALLOC_DONE))
860 reorganize_buffers (dev, dmap_out);
861
862 dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
863 DMAbuf_start_output (dev, 0, dmap_out->fragment_size);
864 }
865
866 audio_devs[dev]->enable_bits = bits;
867 if (changed && audio_devs[dev]->trigger)
868 audio_devs[dev]->trigger (dev, bits * audio_devs[dev]->go);
869 restore_flags (flags);
870 }
871 case SNDCTL_DSP_GETTRIGGER:
872 return snd_ioctl_return ((int *) arg, audio_devs[dev]->enable_bits);
873 break;
874
875 case SNDCTL_DSP_SETSYNCRO:
876
877 if (!audio_devs[dev]->trigger)
878 return -EINVAL;
879
880 audio_devs[dev]->trigger (dev, 0);
881 audio_devs[dev]->go = 0;
882 return 0;
883 break;
884
885 case SNDCTL_DSP_GETIPTR:
886 {
887 count_info info;
888 unsigned long flags;
889
890 save_flags (flags);
891 cli ();
892 info.bytes = audio_devs[dev]->dmap_in->byte_counter;
893 info.ptr = get_buffer_pointer (dev, audio_devs[dev]->dmachan2, audio_devs[dev]->dmap_in);
894 info.blocks = audio_devs[dev]->dmap_in->qlen;
895 info.bytes += info.ptr;
896 memcpy_tofs ((&((char *) arg)[0]), (char *) &info, sizeof (info));
897
898 if (audio_devs[dev]->dmap_in->mapping_flags & DMA_MAP_MAPPED)
899 audio_devs[dev]->dmap_in->qlen = 0;
900 restore_flags (flags);
901 return 0;
902 }
903 break;
904
905 case SNDCTL_DSP_GETOPTR:
906 {
907 count_info info;
908 unsigned long flags;
909
910 save_flags (flags);
911 cli ();
912 info.bytes = audio_devs[dev]->dmap_out->byte_counter;
913 info.ptr = get_buffer_pointer (dev, audio_devs[dev]->dmachan1, audio_devs[dev]->dmap_out);
914 info.blocks = audio_devs[dev]->dmap_out->qlen;
915 info.bytes += info.ptr;
916 memcpy_tofs ((&((char *) arg)[0]), (char *) &info, sizeof (info));
917
918 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
919 audio_devs[dev]->dmap_out->qlen = 0;
920 restore_flags (flags);
921 return 0;
922 }
923 break;
924
925
926 default:
927 return audio_devs[dev]->ioctl (dev, cmd, arg, local);
928 }
929
930 }
931
932
933
934
935
936
937 void
938 DMAbuf_start_devices (unsigned int devmask)
939 {
940 int dev;
941
942 for (dev = 0; dev < num_audiodevs; dev++)
943 if (devmask & (1 << dev))
944 if (audio_devs[dev]->open_mode != 0)
945 if (!audio_devs[dev]->go)
946 {
947
948 audio_devs[dev]->go = 1;
949
950 if (audio_devs[dev]->trigger)
951 audio_devs[dev]->trigger (dev,
952 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
953 }
954 }
955
956 static int
957 space_in_queue (int dev)
958 {
959 int len, max, tmp;
960 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
961
962 if (dmap->qlen >= dmap->nbufs)
963 return 0;
964
965
966
967
968
969
970 max = dmap->max_fragments;
971 len = dmap->qlen;
972
973 if (audio_devs[dev]->local_qlen)
974 {
975 tmp = audio_devs[dev]->local_qlen (dev);
976 if (tmp && len)
977 tmp--;
978
979
980 len += tmp;
981 }
982
983 if (len >= max)
984 return 0;
985 return 1;
986 }
987
988 int
989 DMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
990 {
991 unsigned long flags;
992 int abort, err = EIO;
993 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
994
995 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
996 {
997 printk ("Sound: Can't write to mmapped device (3)\n");
998 return -EINVAL;
999 }
1000
1001 if (dmap->dma_mode == DMODE_INPUT)
1002 {
1003 dma_reset (dev);
1004 dmap->dma_mode = DMODE_NONE;
1005 }
1006 else if (dmap->flags & DMA_RESTART)
1007 {
1008 dma_sync (dev);
1009 dma_reset_output (dev);
1010 }
1011
1012 dmap->flags &= ~DMA_RESTART;
1013
1014 if (!(dmap->flags & DMA_ALLOC_DONE))
1015 reorganize_buffers (dev, dmap);
1016
1017 if (!dmap->dma_mode)
1018 {
1019 int err;
1020
1021 dmap->dma_mode = DMODE_OUTPUT;
1022 if ((err = audio_devs[dev]->prepare_for_output (dev,
1023 dmap->fragment_size, dmap->nbufs)) < 0)
1024 return err;
1025 }
1026
1027 save_flags (flags);
1028 cli ();
1029
1030 abort = 0;
1031 while (!space_in_queue (dev) &&
1032 !abort)
1033 {
1034 int timeout;
1035
1036 if (dontblock)
1037 {
1038 restore_flags (flags);
1039 return -EAGAIN;
1040 }
1041
1042 if (!(audio_devs[dev]->enable_bits & PCM_ENABLE_OUTPUT) &&
1043 audio_devs[dev]->go)
1044 {
1045 restore_flags (flags);
1046 return -EAGAIN;
1047 }
1048
1049
1050
1051
1052 if (!audio_devs[dev]->go)
1053 timeout = 0;
1054 else
1055 timeout = 2 * HZ;
1056
1057
1058 {
1059 unsigned long tl;
1060
1061 if (timeout)
1062 current_set_timeout (tl = jiffies + (timeout));
1063 else
1064 tl = (unsigned long) -1;
1065 out_sleep_flag[dev].mode = WK_SLEEP;
1066 module_interruptible_sleep_on (&out_sleeper[dev]);
1067 if (!(out_sleep_flag[dev].mode & WK_WAKEUP))
1068 {
1069 if (jiffies >= tl)
1070 out_sleep_flag[dev].mode |= WK_TIMEOUT;
1071 }
1072 out_sleep_flag[dev].mode &= ~WK_SLEEP;
1073 };
1074 if ((out_sleep_flag[dev].mode & WK_TIMEOUT))
1075 {
1076 printk ("Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
1077 err = EIO;
1078 abort = 1;
1079 ;
1080 audio_devs[dev]->reset (dev);
1081 }
1082 else if (current_got_fatal_signal ())
1083 {
1084 err = EINTR;
1085 abort = 1;
1086 }
1087 }
1088 restore_flags (flags);
1089
1090 if (!space_in_queue (dev))
1091 {
1092 return -err;
1093 }
1094
1095 *buf = dmap->raw_buf + dmap->qtail * dmap->fragment_size;
1096 *size = dmap->fragment_size;
1097 #if 1
1098 memset (*buf,
1099 dmap->neutral_byte,
1100 *size);
1101 #endif
1102 dmap->counts[dmap->qtail] = 0;
1103
1104 return dmap->qtail;
1105 }
1106
1107 int
1108 DMAbuf_get_curr_buffer (int dev, int *buf_no, char **dma_buf, int *buf_ptr, int *buf_size)
1109 {
1110 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1111
1112 if (dmap->cfrag < 0)
1113 return -1;
1114
1115 *dma_buf = dmap->raw_buf + dmap->qtail * dmap->fragment_size;
1116 *buf_ptr = dmap->counts[dmap->qtail];
1117 *buf_size = dmap->fragment_size;
1118 return *buf_no = dmap->cfrag;
1119 }
1120
1121 int
1122 DMAbuf_set_count (int dev, int buff_no, int l)
1123 {
1124 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1125
1126 if (buff_no == dmap->qtail)
1127 {
1128 dmap->cfrag = buff_no;
1129 dmap->counts[buff_no] = l;
1130 }
1131 else
1132 dmap->cfrag = -1;
1133 return 0;
1134 }
1135
1136 int
1137 DMAbuf_start_output (int dev, int buff_no, int l)
1138 {
1139 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1140
1141 dmap->cfrag = -1;
1142
1143
1144
1145
1146 if (audio_devs[dev]->dmap_out->mapping_flags & DMA_MAP_MAPPED)
1147 {
1148 l = dmap->fragment_size;
1149 dmap->counts[dmap->qtail] = l;
1150 dmap->flags &= ~DMA_RESTART;
1151 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1152 }
1153 else
1154 {
1155
1156
1157 dmap->qlen++;
1158 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1159 printk ("\nSound: Audio queue2 corrupted for dev%d (%d/%d)\n",
1160 dev, dmap->qlen, dmap->nbufs);
1161
1162 dmap->counts[dmap->qtail] = l;
1163
1164 if ((l != dmap->fragment_size) &&
1165 ((audio_devs[dev]->flags & DMA_AUTOMODE) &&
1166 audio_devs[dev]->flags & NEEDS_RESTART))
1167 dmap->flags |= DMA_RESTART;
1168 else
1169 dmap->flags &= ~DMA_RESTART;
1170
1171 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1172 }
1173
1174 if (!(dmap->flags & DMA_ACTIVE))
1175 {
1176 dmap->flags |= DMA_ACTIVE;
1177 audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1178 dmap->qhead * dmap->fragment_size,
1179 dmap->counts[dmap->qhead], 0,
1180 !(audio_devs[dev]->flags & DMA_AUTOMODE) ||
1181 !(dmap->flags & DMA_STARTED));
1182 dmap->flags |= DMA_STARTED;
1183 if (audio_devs[dev]->trigger)
1184 audio_devs[dev]->trigger (dev,
1185 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1186 }
1187
1188 return 0;
1189 }
1190
1191 int
1192 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
1193 {
1194 int chan;
1195 struct dma_buffparms *dmap;
1196 unsigned long flags;
1197
1198 if (dma_mode == DMA_MODE_WRITE)
1199 {
1200 chan = audio_devs[dev]->dmachan1;
1201 dmap = audio_devs[dev]->dmap_out;
1202 }
1203 else
1204 {
1205 chan = audio_devs[dev]->dmachan2;
1206 dmap = audio_devs[dev]->dmap_in;
1207 }
1208
1209
1210
1211
1212
1213
1214 if (audio_devs[dev]->flags & DMA_AUTOMODE)
1215 {
1216
1217
1218
1219 save_flags (flags);
1220 cli ();
1221 disable_dma (chan);
1222 clear_dma_ff (chan);
1223 set_dma_mode (chan, dma_mode | DMA_AUTOINIT);
1224 set_dma_addr (chan, dmap->raw_buf_phys);
1225 set_dma_count (chan, dmap->bytes_in_use);
1226 enable_dma (chan);
1227 restore_flags (flags);
1228 }
1229 else
1230 {
1231 save_flags (flags);
1232 cli ();
1233 disable_dma (chan);
1234 clear_dma_ff (chan);
1235 set_dma_mode (chan, dma_mode);
1236 set_dma_addr (chan, physaddr);
1237 set_dma_count (chan, count);
1238 enable_dma (chan);
1239 restore_flags (flags);
1240 }
1241
1242 return count;
1243 }
1244
1245 long
1246 DMAbuf_init (long mem_start)
1247 {
1248 int dev;
1249
1250
1251
1252
1253
1254
1255 for (dev = 0; dev < num_audiodevs; dev++)
1256 if (audio_devs[dev]->dmap_out == NULL)
1257 {
1258 audio_devs[dev]->dmap_out =
1259 audio_devs[dev]->dmap_in =
1260 &dmaps[ndmaps++];
1261
1262 if (audio_devs[dev]->flags & DMA_DUPLEX)
1263 audio_devs[dev]->dmap_in =
1264 &dmaps[ndmaps++];
1265 }
1266 return mem_start;
1267 }
1268
1269 void
1270 DMAbuf_outputintr (int dev, int event_type)
1271 {
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282 unsigned long flags;
1283 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
1284
1285 dmap->byte_counter += dmap->counts[dmap->qhead];
1286
1287 #ifdef OS_DMA_INTR
1288 sound_dma_intr (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1289 #endif
1290
1291 if (dmap->mapping_flags & DMA_MAP_MAPPED)
1292 {
1293
1294 int p;
1295
1296 p = dmap->fragment_size * dmap->qhead;
1297 memset (dmap->raw_buf + p,
1298 dmap->neutral_byte,
1299 dmap->fragment_size);
1300
1301 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1302 dmap->qlen++;
1303 dmap->flags &= ~DMA_ACTIVE;
1304 dmap->counts[dmap->qhead] = dmap->fragment_size;
1305
1306 if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1307 {
1308 audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1309 dmap->qhead * dmap->fragment_size,
1310 dmap->counts[dmap->qhead], 1,
1311 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1312 if (audio_devs[dev]->trigger)
1313 audio_devs[dev]->trigger (dev,
1314 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1315 }
1316 dmap->flags |= DMA_ACTIVE;
1317 }
1318 else if (event_type != 2)
1319 {
1320 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1321 {
1322 printk ("\nSound: Audio queue3 corrupted for dev%d (%d/%d)\n",
1323 dev, dmap->qlen, dmap->nbufs);
1324 return;
1325 }
1326
1327 dmap->qlen--;
1328 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1329 dmap->flags &= ~DMA_ACTIVE;
1330
1331 if (event_type == 1 && dmap->qlen < 1)
1332 {
1333 dmap->underrun_count++;
1334
1335 if (dmap->closing)
1336 {
1337 audio_devs[dev]->halt_xfer (dev);
1338 }
1339 else
1340 {
1341 dmap->qlen++;
1342 dmap->cfrag = -1;
1343 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1344
1345 memset (audio_devs[dev]->dmap_out->raw_buf,
1346 audio_devs[dev]->dmap_out->neutral_byte,
1347 audio_devs[dev]->dmap_out->bytes_in_use);
1348 }
1349 }
1350
1351 if (dmap->qlen)
1352 {
1353 if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1354 {
1355 audio_devs[dev]->output_block (dev, dmap->raw_buf_phys +
1356 dmap->qhead * dmap->fragment_size,
1357 dmap->counts[dmap->qhead], 1,
1358 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1359 if (audio_devs[dev]->trigger)
1360 audio_devs[dev]->trigger (dev,
1361 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1362 }
1363 dmap->flags |= DMA_ACTIVE;
1364 }
1365 }
1366
1367 save_flags (flags);
1368 cli ();
1369 if ((out_sleep_flag[dev].mode & WK_SLEEP))
1370 {
1371 {
1372 out_sleep_flag[dev].mode = WK_WAKEUP;
1373 module_wake_up (&out_sleeper[dev]);
1374 };
1375 }
1376 restore_flags (flags);
1377 }
1378
1379 void
1380 DMAbuf_inputintr (int dev)
1381 {
1382 unsigned long flags;
1383 struct dma_buffparms *dmap = audio_devs[dev]->dmap_in;
1384
1385 dmap->byte_counter += dmap->fragment_size;
1386
1387 #ifdef OS_DMA_INTR
1388 sound_dma_intr (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1389 #endif
1390
1391 if (dmap->mapping_flags & DMA_MAP_MAPPED)
1392 {
1393 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1394 dmap->qlen++;
1395
1396 if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1397 {
1398 audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
1399 dmap->qtail * dmap->fragment_size,
1400 dmap->fragment_size, 1,
1401 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1402 if (audio_devs[dev]->trigger)
1403 audio_devs[dev]->trigger (dev,
1404 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1405 }
1406
1407 dmap->flags |= DMA_ACTIVE;
1408 }
1409 else if (dmap->qlen == (dmap->nbufs - 1))
1410 {
1411 printk ("Sound: Recording overrun\n");
1412 dmap->underrun_count++;
1413
1414 if (audio_devs[dev]->flags & DMA_AUTOMODE)
1415 {
1416
1417 if ((audio_devs[dev]->flags & DMA_DUPLEX) &&
1418 audio_devs[dev]->halt_input)
1419 audio_devs[dev]->halt_input (dev);
1420 else
1421 audio_devs[dev]->halt_xfer (dev);
1422
1423 dmap->flags &= ~DMA_ACTIVE;
1424 if (audio_devs[dev]->flags & DMA_AUTOMODE)
1425 dmap->flags |= DMA_RESTART;
1426 else
1427 dmap->flags &= ~DMA_RESTART;
1428 }
1429 }
1430 else
1431 {
1432 dmap->qlen++;
1433 if (dmap->qlen <= 0 || dmap->qlen > dmap->nbufs)
1434 printk ("\nSound: Audio queue4 corrupted for dev%d (%d/%d)\n",
1435 dev, dmap->qlen, dmap->nbufs);
1436 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1437 }
1438
1439 if (!(audio_devs[dev]->flags & DMA_AUTOMODE))
1440 {
1441 audio_devs[dev]->start_input (dev, dmap->raw_buf_phys +
1442 dmap->qtail * dmap->fragment_size,
1443 dmap->fragment_size, 1,
1444 !(audio_devs[dev]->flags & DMA_AUTOMODE));
1445 if (audio_devs[dev]->trigger)
1446 audio_devs[dev]->trigger (dev,
1447 audio_devs[dev]->enable_bits * audio_devs[dev]->go);
1448 }
1449
1450 dmap->flags |= DMA_ACTIVE;
1451
1452 save_flags (flags);
1453 cli ();
1454 if ((in_sleep_flag[dev].mode & WK_SLEEP))
1455 {
1456 {
1457 in_sleep_flag[dev].mode = WK_WAKEUP;
1458 module_wake_up (&in_sleeper[dev]);
1459 };
1460 }
1461 restore_flags (flags);
1462 }
1463
1464 int
1465 DMAbuf_open_dma (int dev)
1466 {
1467 int chan = audio_devs[dev]->dmachan1;
1468 int err;
1469 unsigned long flags;
1470
1471 if ((err = open_dmap (dev, OPEN_READWRITE, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1)) < 0)
1472 {
1473 return -EBUSY;
1474 }
1475 dma_init_buffers (dev, audio_devs[dev]->dmap_out);
1476 audio_devs[dev]->dmap_out->flags |= DMA_ALLOC_DONE;
1477 audio_devs[dev]->dmap_out->fragment_size = audio_devs[dev]->buffsize;
1478
1479
1480 if (audio_devs[dev]->flags & DMA_DUPLEX)
1481 {
1482 if ((err = open_dmap (dev, OPEN_READWRITE, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2)) < 0)
1483 {
1484 printk ("Unable to grab DMA%d for the audio driver\n",
1485 audio_devs[dev]->dmachan2);
1486 close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1487 return -EBUSY;
1488 }
1489 dma_init_buffers (dev, audio_devs[dev]->dmap_in);
1490 audio_devs[dev]->dmap_in->flags |= DMA_ALLOC_DONE;
1491 audio_devs[dev]->dmap_in->fragment_size = audio_devs[dev]->buffsize;
1492
1493 }
1494 else
1495 {
1496 audio_devs[dev]->dmap_in = audio_devs[dev]->dmap_out;
1497 audio_devs[dev]->dmachan2 = audio_devs[dev]->dmachan1;
1498 }
1499
1500
1501 save_flags (flags);
1502 cli ();
1503 disable_dma (chan);
1504 clear_dma_ff (chan);
1505 restore_flags (flags);
1506
1507 return 0;
1508 }
1509
1510 void
1511 DMAbuf_close_dma (int dev)
1512 {
1513 DMAbuf_reset_dma (dev);
1514 close_dmap (dev, audio_devs[dev]->dmap_out, audio_devs[dev]->dmachan1);
1515
1516 if (audio_devs[dev]->flags & DMA_DUPLEX)
1517 close_dmap (dev, audio_devs[dev]->dmap_in, audio_devs[dev]->dmachan2);
1518
1519 }
1520
1521 void
1522 DMAbuf_reset_dma (int dev)
1523 {
1524 }
1525
1526 int
1527 DMAbuf_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
1528 {
1529 struct dma_buffparms *dmap;
1530 unsigned long flags;
1531
1532 switch (sel_type)
1533 {
1534 case SEL_IN:
1535 dmap = audio_devs[dev]->dmap_in;
1536
1537 if (dmap->mapping_flags & DMA_MAP_MAPPED)
1538 {
1539 if (dmap->qlen)
1540 return 1;
1541
1542 save_flags (flags);
1543 cli ();
1544 in_sleep_flag[dev].mode = WK_SLEEP;
1545 module_select_wait (&in_sleeper[dev], wait);
1546 restore_flags (flags);
1547 return 0;
1548 }
1549
1550 if (dmap->dma_mode != DMODE_INPUT)
1551 {
1552 if ((audio_devs[dev]->flags & DMA_DUPLEX) && !dmap->qlen &&
1553 audio_devs[dev]->enable_bits & PCM_ENABLE_INPUT &&
1554 audio_devs[dev]->go)
1555 {
1556 unsigned long flags;
1557
1558 save_flags (flags);
1559 cli ();
1560 activate_recording (dev, dmap);
1561 restore_flags (flags);
1562 }
1563 return 0;
1564 }
1565
1566 if (!dmap->qlen)
1567 {
1568 save_flags (flags);
1569 cli ();
1570 in_sleep_flag[dev].mode = WK_SLEEP;
1571 module_select_wait (&in_sleeper[dev], wait);
1572 restore_flags (flags);
1573 return 0;
1574 }
1575 return 1;
1576 break;
1577
1578 case SEL_OUT:
1579 dmap = audio_devs[dev]->dmap_out;
1580
1581 if (dmap->mapping_flags & DMA_MAP_MAPPED)
1582 {
1583 if (dmap->qlen)
1584 return 1;
1585
1586 save_flags (flags);
1587 cli ();
1588 out_sleep_flag[dev].mode = WK_SLEEP;
1589 module_select_wait (&out_sleeper[dev], wait);
1590 restore_flags (flags);
1591 return 0;
1592 }
1593
1594 if (dmap->dma_mode == DMODE_INPUT)
1595 {
1596 return 0;
1597 }
1598
1599 if (dmap->dma_mode == DMODE_NONE)
1600 {
1601 return 1;
1602 }
1603
1604 if (!space_in_queue (dev))
1605 {
1606 save_flags (flags);
1607 cli ();
1608 out_sleep_flag[dev].mode = WK_SLEEP;
1609 module_select_wait (&out_sleeper[dev], wait);
1610 restore_flags (flags);
1611 return 0;
1612 }
1613 return 1;
1614 break;
1615
1616 case SEL_EX:
1617 return 0;
1618 }
1619
1620 return 0;
1621 }
1622
1623
1624 #else
1625
1626
1627
1628
1629 int
1630 DMAbuf_open (int dev, int mode)
1631 {
1632 return -ENXIO;
1633 }
1634
1635 int
1636 DMAbuf_release (int dev, int mode)
1637 {
1638 return 0;
1639 }
1640
1641 int
1642 DMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
1643 {
1644 return -EIO;
1645 }
1646
1647 int
1648 DMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
1649 {
1650 return -EIO;
1651 }
1652
1653 int
1654 DMAbuf_rmchars (int dev, int buff_no, int c)
1655 {
1656 return -EIO;
1657 }
1658
1659 int
1660 DMAbuf_start_output (int dev, int buff_no, int l)
1661 {
1662 return -EIO;
1663 }
1664
1665 int
1666 DMAbuf_ioctl (int dev, unsigned int cmd, caddr_t arg, int local)
1667 {
1668 return -EIO;
1669 }
1670
1671 long
1672 DMAbuf_init (long mem_start)
1673 {
1674 return mem_start;
1675 }
1676
1677 int
1678 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
1679 {
1680 return -EIO;
1681 }
1682
1683 int
1684 DMAbuf_open_dma (int dev)
1685 {
1686 return -ENXIO;
1687 }
1688
1689 void
1690 DMAbuf_close_dma (int dev)
1691 {
1692 return;
1693 }
1694
1695 void
1696 DMAbuf_reset_dma (int dev)
1697 {
1698 return;
1699 }
1700
1701 void
1702 DMAbuf_inputintr (int dev)
1703 {
1704 return;
1705 }
1706
1707 void
1708 DMAbuf_outputintr (int dev, int underrun_flag)
1709 {
1710 return;
1711 }
1712 #endif