This source file includes following definitions.
- reorganize_buffers
- dma_init_buffers
- DMAbuf_open
- dma_reset
- dma_sync
- DMAbuf_release
- DMAbuf_getrdbuffer
- DMAbuf_rmchars
- DMAbuf_read
- DMAbuf_ioctl
- DMAbuf_getwrbuffer
- DMAbuf_start_output
- DMAbuf_start_dma
- DMAbuf_init
- DMAbuf_outputintr
- DMAbuf_inputintr
- DMAbuf_open_dma
- DMAbuf_close_dma
- DMAbuf_reset_dma
- DMAbuf_open
- DMAbuf_release
- DMAbuf_read
- 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 #include "sound_calls.h"
35
36 #if !defined(EXCLUDE_AUDIO) || !defined(EXCLUDE_GUS)
37
38 #define MAX_SUB_BUFFERS (32*MAX_REALTIME_FACTOR)
39
40
41
42
43
44
45
46
47
48 #define DMODE_NONE 0
49 #define DMODE_OUTPUT 1
50 #define DMODE_INPUT 2
51
52 DEFINE_WAIT_QUEUES (dev_sleeper[MAX_DSP_DEV], dev_sleep_flag[MAX_DSP_DEV]);
53
54 static int dma_mode[MAX_DSP_DEV] =
55 {0};
56
57 static volatile int dmabuf_interrupted[MAX_DSP_DEV] =
58 {0};
59
60
61
62
63
64 char *snd_raw_buf[MAX_DSP_DEV][DSP_BUFFCOUNT] =
65 {
66 {NULL}};
67 unsigned long snd_raw_buf_phys[MAX_DSP_DEV][DSP_BUFFCOUNT];
68 int snd_raw_count[MAX_DSP_DEV];
69
70
71
72
73
74 static int dev_busy[MAX_DSP_DEV];
75 static int dev_needs_restart[MAX_DSP_DEV];
76 static int dev_modes[MAX_DSP_DEV];
77 static int dev_active[MAX_DSP_DEV];
78 static int dev_started[MAX_DSP_DEV];
79 static int dev_qlen[MAX_DSP_DEV];
80 static int dev_qhead[MAX_DSP_DEV];
81 static int dev_qtail[MAX_DSP_DEV];
82 static int dev_underrun[MAX_DSP_DEV];
83 static int bufferalloc_done[MAX_DSP_DEV] =
84 {0};
85
86
87
88
89
90 static int dev_nbufs[MAX_DSP_DEV];
91
92 static int dev_counts[MAX_DSP_DEV][MAX_SUB_BUFFERS];
93 static int dev_subdivision[MAX_DSP_DEV];
94 static unsigned long dev_buf_phys[MAX_DSP_DEV][MAX_SUB_BUFFERS];
95 static char *dev_buf[MAX_DSP_DEV][MAX_SUB_BUFFERS] =
96 {{NULL}};
97 static int dev_buffsize[MAX_DSP_DEV];
98
99 static void
100 reorganize_buffers (int dev)
101 {
102
103
104
105
106 unsigned i, p, n;
107 unsigned sr, nc, sz, bsz;
108
109 sr = dsp_devs[dev]->ioctl (dev, SOUND_PCM_READ_RATE, 0, 1);
110 nc = dsp_devs[dev]->ioctl (dev, SOUND_PCM_READ_CHANNELS, 0, 1);
111 sz = dsp_devs[dev]->ioctl (dev, SOUND_PCM_READ_BITS, 0, 1);
112
113 if (sr < 1 || nc < 1 || sz < 1)
114 {
115 printk ("SOUND: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n", dev, sr, nc, sz);
116 sr = DSP_DEFAULT_SPEED;
117 nc = 1;
118 sz = 8;
119 }
120
121 sz /= 8;
122
123 sz = sr * nc * sz;
124
125
126
127
128
129 bsz = sound_buffsizes[dev];
130
131 while (bsz > sz)
132 bsz >>= 1;
133
134 if (sound_buffcounts[dev] == 1 && bsz == sound_buffsizes[dev])
135 bsz >>= 1;
136
137 if (dev_subdivision[dev] == 0)
138 dev_subdivision[dev] = 1;
139
140 bsz /= dev_subdivision[dev];
141
142 if (bsz == 0) bsz = 4096;
143
144 while ((sound_buffsizes[dev]*sound_buffcounts[dev])/bsz > MAX_SUB_BUFFERS)
145 bsz <<= 1;
146
147 dev_buffsize[dev] = bsz;
148 n = 0;
149
150
151
152
153
154 for (i = 0; i < snd_raw_count[dev]; i++)
155 {
156 p = 0;
157
158 while ((p + bsz) <= sound_buffsizes[dev])
159 {
160 dev_buf[dev][n] = snd_raw_buf[dev][i] + p;
161 dev_buf_phys[dev][n] = snd_raw_buf_phys[dev][i] + p;
162 p += bsz;
163 n++;
164 }
165 }
166
167 dev_nbufs[dev] = n;
168
169 for (i = 0; i < dev_nbufs[dev]; i++)
170 {
171 dev_counts[dev][i] = 0;
172 }
173
174 bufferalloc_done[dev] = 1;
175 }
176
177 static void
178 dma_init_buffers(int dev)
179 {
180 RESET_WAIT_QUEUE (dev_sleeper[dev], dev_sleep_flag[dev]);
181 dev_underrun[dev] = 0;
182
183 dev_busy[dev] = 1;
184
185 bufferalloc_done[dev] = 0;
186
187 dev_active[dev] = dev_qlen[dev] = dev_qtail[dev] = dev_qhead[dev] = 0;
188 dev_needs_restart[dev] = dev_started[dev] = 0;
189 dma_mode[dev] = DMODE_NONE;
190 }
191
192 int
193 DMAbuf_open (int dev, int mode)
194 {
195 int retval;
196
197 if (dev >= num_dspdevs)
198 {
199 printk ("PCM device %d not installed.\n", dev);
200 return RET_ERROR (ENXIO);
201 }
202
203 if (dev_busy[dev])
204 return RET_ERROR (EBUSY);
205
206 if (!dsp_devs[dev])
207 {
208 printk ("DSP device %d not initialized\n", dev);
209 return RET_ERROR (ENXIO);
210 }
211
212 #ifdef USE_RUNTIME_DMAMEM
213 sound_dma_malloc(dev);
214 #endif
215
216 if (snd_raw_buf[dev][0] == NULL)
217 return RET_ERROR (ENOSPC);
218
219 if ((retval = dsp_devs[dev]->open (dev, mode)) < 0)
220 return retval;
221
222 dev_modes[dev] = mode;
223 dev_subdivision[dev] = 0;
224
225 dma_init_buffers(dev);
226 dsp_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_BITS, 8, 1);
227 dsp_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_CHANNELS, 1, 1);
228 dsp_devs[dev]->ioctl (dev, SOUND_PCM_WRITE_RATE, DSP_DEFAULT_SPEED, 1);
229
230 return 0;
231 }
232
233 static void
234 dma_reset (int dev)
235 {
236 int retval;
237 unsigned long flags;
238
239 DISABLE_INTR(flags);
240 dsp_devs[dev]->reset (dev);
241 dsp_devs[dev]->close (dev);
242
243 if ((retval = dsp_devs[dev]->open (dev, dev_modes[dev])) < 0)
244 printk("Sound: Reset failed - Can't reopen device\n");
245 RESTORE_INTR(flags);
246
247 dma_init_buffers(dev);
248 reorganize_buffers(dev);
249 }
250
251 static int
252 dma_sync (int dev)
253 {
254 unsigned long flags;
255 unsigned long time;
256 int timed_out;
257
258 if (dma_mode[dev] == DMODE_OUTPUT)
259 {
260 DISABLE_INTR (flags);
261
262 timed_out = 0;
263 time = GET_TIME ();
264
265 while ((!(PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]) ||
266 dmabuf_interrupted[dev]) && !timed_out)
267 && dev_qlen[dev])
268 {
269 DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 10 * HZ);
270 if ((GET_TIME () - time) > (10 * HZ))
271 timed_out = 1;
272 }
273 RESTORE_INTR (flags);
274
275
276
277
278
279
280 DISABLE_INTR (flags);
281 if (dsp_devs[dev]->has_output_drained)
282 {
283 while (!(PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]) ||
284 dmabuf_interrupted[dev])
285 && !dsp_devs[dev]->has_output_drained (dev))
286 {
287 DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], HZ / 4);
288 }
289 }
290 RESTORE_INTR (flags);
291 }
292 return dev_qlen[dev];
293 }
294
295 int
296 DMAbuf_release (int dev, int mode)
297 {
298
299 if (!(PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]) ||
300 dmabuf_interrupted[dev])
301 && (dma_mode[dev] == DMODE_OUTPUT))
302 {
303 dma_sync (dev);
304 }
305
306 #ifdef USE_RUNTIME_DMAMEM
307 sound_dma_free(dev);
308 #endif
309
310 dsp_devs[dev]->reset (dev);
311
312 dsp_devs[dev]->close (dev);
313
314 dma_mode[dev] = DMODE_NONE;
315 dev_busy[dev] = 0;
316
317 return 0;
318 }
319
320 int
321 DMAbuf_getrdbuffer (int dev, char **buf, int *len)
322 {
323 unsigned long flags;
324 int err = EIO;
325
326 DISABLE_INTR (flags);
327 if (!dev_qlen[dev])
328 {
329 if (dev_needs_restart[dev])
330 {
331 dma_reset(dev);
332 dev_needs_restart[dev] = 0;
333 }
334
335 if (dma_mode[dev] == DMODE_OUTPUT)
336 {
337 dma_sync(dev);
338 dma_reset(dev);
339 dma_mode[dev] = DMODE_NONE;
340 }
341
342 if (!bufferalloc_done[dev])
343 reorganize_buffers (dev);
344
345 if (!dma_mode[dev])
346 {
347 int err;
348
349 if ((err = dsp_devs[dev]->prepare_for_input (dev,
350 dev_buffsize[dev], dev_nbufs[dev])) < 0)
351 {
352 RESTORE_INTR (flags);
353 return err;
354 }
355 dma_mode[dev] = DMODE_INPUT;
356 }
357
358 if (!dev_active[dev])
359 {
360 dsp_devs[dev]->start_input (dev, dev_buf_phys[dev][dev_qtail[dev]],
361 dev_buffsize[dev], 0,
362 !sound_dma_automode[dev] ||
363 !dev_started[dev]);
364 dev_active[dev] = 1;
365 dev_started[dev] = 1;
366 }
367
368
369 DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 2 * HZ);
370 if (TIMED_OUT (dev_sleeper[dev], dev_sleep_flag[dev]))
371 {
372 printk ("Sound: DMA timed out - IRQ/DRQ config error?\n");
373 err = EIO;
374 SET_ABORT_FLAG (dev_sleeper[dev], dev_sleep_flag[dev]);
375 }
376 else
377 err = EINTR;
378 }
379 RESTORE_INTR (flags);
380
381 if (!dev_qlen[dev])
382 return RET_ERROR (err);
383
384 *buf = &dev_buf[dev][dev_qhead[dev]][dev_counts[dev][dev_qhead[dev]]];
385 *len = dev_buffsize[dev] - dev_counts[dev][dev_qhead[dev]];
386
387 return dev_qhead[dev];
388 }
389
390 int
391 DMAbuf_rmchars (int dev, int buff_no, int c)
392 {
393 int p = dev_counts[dev][dev_qhead[dev]] + c;
394
395 if (p >= dev_buffsize[dev])
396 {
397 dev_counts[dev][dev_qhead[dev]] = 0;
398 dev_qlen[dev]--;
399 dev_qhead[dev] = (dev_qhead[dev] + 1) % dev_nbufs[dev];
400 }
401 else
402 dev_counts[dev][dev_qhead[dev]] = p;
403
404 return 0;
405 }
406
407 int
408 DMAbuf_read (int dev, snd_rw_buf * user_buf, int count)
409 {
410 char *dmabuf;
411 int buff_no, c, err;
412
413
414
415
416
417
418 if ((buff_no = DMAbuf_getrdbuffer (dev, &dmabuf, &c)) < 0)
419 return buff_no;
420
421 if (c > count)
422 c = count;
423
424 COPY_TO_USER (user_buf, 0, dmabuf, c);
425
426 if ((err = DMAbuf_rmchars (dev, buff_no, c)) < 0)
427 return err;
428 return c;
429
430 }
431
432 int
433 DMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
434 {
435 switch (cmd)
436 {
437 case SNDCTL_DSP_RESET:
438 dma_reset (dev);
439 return 0;
440 break;
441
442 case SNDCTL_DSP_SYNC:
443 dma_sync (dev);
444 dma_reset (dev);
445 return 0;
446 break;
447
448 case SNDCTL_DSP_GETBLKSIZE:
449 if (!bufferalloc_done[dev])
450 reorganize_buffers (dev);
451
452 return IOCTL_OUT (arg, dev_buffsize[dev]);
453 break;
454
455 case SNDCTL_DSP_SUBDIVIDE:
456 {
457 int fact = IOCTL_IN(arg);
458
459 if (fact == 0)
460 {
461 fact = dev_subdivision[dev];
462 if (fact == 0) fact = 1;
463 return IOCTL_OUT(arg, fact);
464 }
465
466 if (dev_subdivision[dev] != 0)
467 return RET_ERROR(EINVAL);
468
469 if (fact > MAX_REALTIME_FACTOR) return RET_ERROR(EINVAL);
470
471 if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact !=16)
472 return RET_ERROR(EINVAL);
473
474 dev_subdivision[dev] = fact;
475 return IOCTL_OUT(arg, fact);
476 }
477 break;
478
479 default:
480 return dsp_devs[dev]->ioctl (dev, cmd, arg, local);
481 }
482
483 return RET_ERROR (EIO);
484 }
485
486 int
487 DMAbuf_getwrbuffer (int dev, char **buf, int *size)
488 {
489 unsigned long flags;
490 int err = EIO;
491
492 if (dma_mode[dev] == DMODE_INPUT)
493 {
494 dma_reset(dev);
495 dma_mode[dev] = DMODE_NONE;
496 }
497 else
498 if (dev_needs_restart[dev])
499 {
500 dma_sync(dev);
501 dma_reset(dev);
502 }
503
504 dev_needs_restart[dev] = 0;
505
506 if (!bufferalloc_done[dev])
507 reorganize_buffers (dev);
508
509 if (!dma_mode[dev])
510 {
511 int err;
512
513 dma_mode[dev] = DMODE_OUTPUT;
514 if ((err = dsp_devs[dev]->prepare_for_output (dev,
515 dev_buffsize[dev], dev_nbufs[dev])) < 0)
516 return err;
517 }
518
519
520 DISABLE_INTR (flags);
521
522 RESET_WAIT_QUEUE (dev_sleeper[dev], dev_sleep_flag[dev]);
523
524 if (dev_qlen[dev] == dev_nbufs[dev])
525 {
526 if (!dev_active[dev])
527 {
528 printk ("Soundcard warning: DMA not activated %d/%d\n",
529 dev_qlen[dev], dev_nbufs[dev]);
530 return RET_ERROR (EIO);
531 }
532
533
534 DO_SLEEP (dev_sleeper[dev], dev_sleep_flag[dev], 2 * HZ);
535 if (TIMED_OUT (dev_sleeper[dev], dev_sleep_flag[dev]))
536 {
537 printk ("Sound: DMA timed out - IRQ/DRQ config error?\n");
538 err = EIO;
539 SET_ABORT_FLAG (dev_sleeper[dev], dev_sleep_flag[dev]);
540 }
541 else if (PROCESS_ABORTING (dev_sleeper[dev], dev_sleep_flag[dev]))
542 err = EINTR;
543 }
544 RESTORE_INTR (flags);
545
546 if (dev_qlen[dev] == dev_nbufs[dev])
547 return RET_ERROR (err);
548
549 *buf = dev_buf[dev][dev_qtail[dev]];
550 *size = dev_buffsize[dev];
551 dev_counts[dev][dev_qtail[dev]] = 0;
552
553 return dev_qtail[dev];
554 }
555
556 int
557 DMAbuf_start_output (int dev, int buff_no, int l)
558 {
559 if (buff_no != dev_qtail[dev])
560 printk ("Soundcard warning: DMA buffers out of sync %d != %d\n", buff_no, dev_qtail[dev]);
561
562 dev_qlen[dev]++;
563
564 dev_counts[dev][dev_qtail[dev]] = l;
565
566 dev_needs_restart[dev] = (l != dev_buffsize[dev]);
567
568 dev_qtail[dev] = (dev_qtail[dev] + 1) % dev_nbufs[dev];
569
570 if (!dev_active[dev])
571 {
572 dev_active[dev] = 1;
573 dsp_devs[dev]->output_block (dev, dev_buf_phys[dev][dev_qhead[dev]],
574 dev_counts[dev][dev_qhead[dev]], 0,
575 !sound_dma_automode[dev] || !dev_started[dev]);
576 dev_started[dev] = 1;
577 }
578
579 return 0;
580 }
581
582 int
583 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
584 {
585 int chan = sound_dsp_dmachan[dev];
586 unsigned long flags;
587
588
589
590
591
592
593
594
595
596
597 if (sound_dma_automode[dev])
598 {
599
600 #ifdef linux
601 DISABLE_INTR (flags);
602 disable_dma (chan);
603 clear_dma_ff (chan);
604 set_dma_mode (chan, dma_mode | DMA_AUTOINIT);
605 set_dma_addr (chan, snd_raw_buf_phys[dev][0]);
606 set_dma_count (chan, sound_buffsizes[dev]);
607 enable_dma (chan);
608 RESTORE_INTR (flags);
609 #else
610
611 #ifdef __386BSD__
612 printk ("sound: Invalid DMA mode for device %d\n", dev);
613
614 isa_dmastart ((dma_mode == DMA_MODE_READ) ? B_READ : B_WRITE,
615 snd_raw_buf_phys[dev][0],
616 sound_buffsizes[dev],
617 chan);
618 #else
619 #if defined(ISC) || defined(SCO)
620 #ifndef DMAMODE_AUTO
621 printk ("sound: Invalid DMA mode for device %d\n", dev);
622 #endif
623 dma_param (chan, ((dma_mode == DMA_MODE_READ) ? DMA_Rdmode : DMA_Wrmode)
624 #ifdef DMAMODE_AUTO
625 | DMAMODE_AUTO
626 #endif
627 ,
628 snd_raw_buf_phys[dev][0], count);
629 dma_enable (chan);
630 #else
631 # error This routine is not valid for this OS.
632 #endif
633 #endif
634
635 #endif
636 }
637 else
638 {
639 #ifdef linux
640 DISABLE_INTR (flags);
641 disable_dma (chan);
642 clear_dma_ff (chan);
643 set_dma_mode (chan, dma_mode);
644 set_dma_addr (chan, physaddr);
645 set_dma_count (chan, count);
646 enable_dma (chan);
647 RESTORE_INTR (flags);
648 #else
649 #ifdef __386BSD__
650 isa_dmastart ((dma_mode == DMA_MODE_READ) ? B_READ : B_WRITE,
651 physaddr,
652 count,
653 chan);
654 #else
655
656 #if defined(ISC) || defined(SCO)
657 dma_param (chan, ((dma_mode == DMA_MODE_READ) ? DMA_Rdmode : DMA_Wrmode),
658 physaddr, count);
659 dma_enable (chan);
660 #else
661 # error This routine is not valid for this OS.
662 #endif
663 #endif
664
665 #endif
666 }
667
668 return count;
669 }
670
671 long
672 DMAbuf_init (long mem_start)
673 {
674 int i;
675
676
677
678
679
680
681 for (i = 0; i < MAX_DSP_DEV; i++)
682 {
683 dev_qlen[i] = 0;
684 dev_qhead[i] = 0;
685 dev_qtail[i] = 0;
686 dev_active[i] = 0;
687 dev_busy[i] = 0;
688 bufferalloc_done[i] = 0;
689 }
690
691 return mem_start;
692 }
693
694 void
695 DMAbuf_outputintr (int dev, int underrun_flag)
696 {
697 unsigned long flags;
698
699 dev_qlen[dev]--;
700 dev_qhead[dev] = (dev_qhead[dev] + 1) % dev_nbufs[dev];
701 dev_active[dev] = 0;
702
703 if (dev_qlen[dev])
704 {
705 dsp_devs[dev]->output_block (dev, dev_buf_phys[dev][dev_qhead[dev]],
706 dev_counts[dev][dev_qhead[dev]], 1,
707 !sound_dma_automode[dev]);
708 dev_active[dev] = 1;
709 }
710 else
711 if (underrun_flag)
712 {
713 dev_underrun[dev]++;
714 dsp_devs[dev]->halt_xfer (dev);
715 dev_needs_restart[dev] = 1;
716 }
717
718 DISABLE_INTR (flags);
719 if (SOMEONE_WAITING (dev_sleeper[dev], dev_sleep_flag[dev]))
720 {
721 WAKE_UP (dev_sleeper[dev], dev_sleep_flag[dev]);
722 }
723 RESTORE_INTR (flags);
724 }
725
726 void
727 DMAbuf_inputintr (int dev)
728 {
729 unsigned long flags;
730
731 if (!dev_busy[dev])
732 {
733 dsp_devs[dev]->close (dev);
734 }
735 else if (dev_qlen[dev] == (dev_nbufs[dev] - 1))
736 {
737 printk("Sound: Recording overrun\n");
738 dev_underrun[dev]++;
739 dsp_devs[dev]->halt_xfer (dev);
740 dev_active[dev] = 0;
741 dev_needs_restart[dev] = 1;
742 }
743 else
744 {
745 dev_qlen[dev]++;
746 dev_qtail[dev] = (dev_qtail[dev] + 1) % dev_nbufs[dev];
747
748 dsp_devs[dev]->start_input (dev, dev_buf_phys[dev][dev_qtail[dev]],
749 dev_buffsize[dev], 1,
750 !sound_dma_automode[dev]);
751 dev_active[dev] = 1;
752 }
753
754 DISABLE_INTR (flags);
755 if (SOMEONE_WAITING (dev_sleeper[dev], dev_sleep_flag[dev]))
756 {
757 WAKE_UP (dev_sleeper[dev], dev_sleep_flag[dev]);
758 }
759 RESTORE_INTR (flags);
760 }
761
762 int
763 DMAbuf_open_dma (int dev)
764 {
765 unsigned long flags;
766 int chan = sound_dsp_dmachan[dev];
767
768 if (ALLOC_DMA_CHN (chan))
769 {
770 printk ("Unable to grab DMA%d for the audio driver\n", chan);
771 return 0;
772 }
773
774 DISABLE_INTR (flags);
775 #ifdef linux
776 disable_dma (chan);
777 clear_dma_ff (chan);
778 #endif
779 RESTORE_INTR (flags);
780
781 return 1;
782 }
783
784 void
785 DMAbuf_close_dma (int dev)
786 {
787 int chan = sound_dsp_dmachan[dev];
788
789 DMAbuf_reset_dma (chan);
790 RELEASE_DMA_CHN (chan);
791 }
792
793 void
794 DMAbuf_reset_dma (int chan)
795 {
796 }
797
798
799
800
801
802
803
804
805
806 #else
807
808
809 int
810 DMAbuf_open (int dev, int mode)
811 {
812 return RET_ERROR (ENXIO);
813 }
814
815 int
816 DMAbuf_release (int dev, int mode)
817 {
818 return 0;
819 }
820
821 int
822 DMAbuf_read (int dev, snd_rw_buf * user_buf, int count)
823 {
824 return RET_ERROR (EIO);
825 }
826
827 int
828 DMAbuf_getwrbuffer (int dev, char **buf, int *size)
829 {
830 return RET_ERROR (EIO);
831 }
832
833 int
834 DMAbuf_getrdbuffer (int dev, char **buf, int *len)
835 {
836 return RET_ERROR (EIO);
837 }
838
839 int
840 DMAbuf_rmchars (int dev, int buff_no, int c)
841 {
842 return RET_ERROR (EIO);
843 }
844
845 int
846 DMAbuf_start_output (int dev, int buff_no, int l)
847 {
848 return RET_ERROR (EIO);
849 }
850
851 int
852 DMAbuf_ioctl (int dev, unsigned int cmd, unsigned int arg, int local)
853 {
854 return RET_ERROR (EIO);
855 }
856
857 long
858 DMAbuf_init (long mem_start)
859 {
860 return mem_start;
861 }
862
863 int
864 DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
865 {
866 return RET_ERROR (EIO);
867 }
868
869 int
870 DMAbuf_open_dma (int chan)
871 {
872 return RET_ERROR (ENXIO);
873 }
874
875 void
876 DMAbuf_close_dma (int chan)
877 {
878 return;
879 }
880
881 void
882 DMAbuf_reset_dma (int chan)
883 {
884 return;
885 }
886
887 void
888 DMAbuf_inputintr (int dev)
889 {
890 return;
891 }
892
893 void
894 DMAbuf_outputintr (int dev, int underrun_flag)
895 {
896 return;
897 }
898
899 #endif
900
901 #endif