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