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