4 * The DMA buffer manager for digitized voice applications
7 * Copyright (C) by Hannu Savolainen 1993-1997
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
13 * Thomas Sailer : moved several static variables into struct audio_operations
14 * (which is grossly misnamed btw.) because they have the same
15 * lifetime as the rest in there and dynamic allocation saves
17 * Thomas Sailer : remove {in,out}_sleep_flag. It was used for the sleeper to
18 * determine if it was woken up by the expiring timeout or by
19 * an explicit wake_up. The return value from schedule_timeout
20 * can be used instead; if 0, the wakeup was due to the timeout.
22 * Rob Riggs Added persistent DMA buffers (1998/10/17)
25 #define BE_CONSERVATIVE
26 #define SAMPLE_ROUNDUP 0
28 #include "sound_config.h"
29 #include <linux/wrapper.h>
31 #define DMAP_FREE_ON_CLOSE 0
32 #define DMAP_KEEP_ON_CLOSE 1
33 extern int sound_dmap_flag
;
35 static void dma_reset_output(int dev
);
36 static void dma_reset_input(int dev
);
37 static int local_start_dma(struct audio_operations
*adev
, unsigned long physaddr
, int count
, int dma_mode
);
41 static int debugmem
= 0; /* switched off by default */
42 static int dma_buffsize
= DSP_BUFFSIZE
;
44 static long dmabuf_timeout(struct dma_buffparms
*dmap
)
48 tmout
= (dmap
->fragment_size
* HZ
) / dmap
->data_rate
;
49 tmout
+= HZ
/ 5; /* Some safety distance */
57 static int sound_alloc_dmap(struct dma_buffparms
*dmap
)
59 char *start_addr
, *end_addr
;
64 dmap
->mapping_flags
&= ~DMA_MAP_MAPPED
;
66 if (dmap
->raw_buf
!= NULL
)
67 return 0; /* Already done */
68 if (dma_buffsize
< 4096)
70 dma_pagesize
= (dmap
->dma
< 4) ? (64 * 1024) : (128 * 1024);
73 * Now check for the Cyrix problem.
76 if(isa_dma_bridge_buggy
==2)
80 dmap
->buffsize
= dma_buffsize
;
81 if (dmap
->buffsize
> dma_pagesize
)
82 dmap
->buffsize
= dma_pagesize
;
85 * Now loop until we get a free buffer. Try to get smaller buffer if
86 * it fails. Don't accept smaller than 8k buffer for performance
89 while (start_addr
== NULL
&& dmap
->buffsize
> PAGE_SIZE
) {
90 for (sz
= 0, size
= PAGE_SIZE
; size
< dmap
->buffsize
; sz
++, size
<<= 1);
91 dmap
->buffsize
= PAGE_SIZE
* (1 << sz
);
92 start_addr
= (char *) __get_free_pages(GFP_ATOMIC
|GFP_DMA
, sz
);
93 if (start_addr
== NULL
)
97 if (start_addr
== NULL
) {
98 printk(KERN_WARNING
"Sound error: Couldn't allocate DMA buffer\n");
101 /* make some checks */
102 end_addr
= start_addr
+ dmap
->buffsize
- 1;
105 printk(KERN_DEBUG
"sound: start 0x%lx, end 0x%lx\n", (long) start_addr
, (long) end_addr
);
107 /* now check if it fits into the same dma-pagesize */
109 if (((long) start_addr
& ~(dma_pagesize
- 1)) != ((long) end_addr
& ~(dma_pagesize
- 1))
110 || end_addr
>= (char *) (MAX_DMA_ADDRESS
)) {
111 printk(KERN_ERR
"sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr
, dmap
->buffsize
);
115 dmap
->raw_buf
= start_addr
;
116 dmap
->raw_buf_phys
= virt_to_bus(start_addr
);
118 for (page
= virt_to_page(start_addr
); page
<= virt_to_page(end_addr
); page
++)
119 mem_map_reserve(page
);
123 static void sound_free_dmap(struct dma_buffparms
*dmap
)
127 unsigned long start_addr
, end_addr
;
129 if (dmap
->raw_buf
== NULL
)
131 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
)
132 return; /* Don't free mmapped buffer. Will use it next time */
133 for (sz
= 0, size
= PAGE_SIZE
; size
< dmap
->buffsize
; sz
++, size
<<= 1);
135 start_addr
= (unsigned long) dmap
->raw_buf
;
136 end_addr
= start_addr
+ dmap
->buffsize
;
138 for (page
= virt_to_page(start_addr
); page
<= virt_to_page(end_addr
); page
++)
139 mem_map_unreserve(page
);
141 free_pages((unsigned long) dmap
->raw_buf
, sz
);
142 dmap
->raw_buf
= NULL
;
146 /* Intel version !!!!!!!!! */
148 static int sound_start_dma(struct dma_buffparms
*dmap
, unsigned long physaddr
, int count
, int dma_mode
)
151 int chan
= dmap
->dma
;
153 /* printk( "Start DMA%d %d, %d\n", chan, (int)(physaddr-dmap->raw_buf_phys), count); */
155 flags
= claim_dma_lock();
158 set_dma_mode(chan
, dma_mode
);
159 set_dma_addr(chan
, physaddr
);
160 set_dma_count(chan
, count
);
162 release_dma_lock(flags
);
167 static void dma_init_buffers(struct dma_buffparms
*dmap
)
169 dmap
->qlen
= dmap
->qhead
= dmap
->qtail
= dmap
->user_counter
= 0;
170 dmap
->byte_counter
= 0;
171 dmap
->max_byte_counter
= 8000 * 60 * 60;
172 dmap
->bytes_in_use
= dmap
->buffsize
;
174 dmap
->dma_mode
= DMODE_NONE
;
175 dmap
->mapping_flags
= 0;
176 dmap
->neutral_byte
= 0x80;
177 dmap
->data_rate
= 8000;
181 dmap
->flags
= DMA_BUSY
; /* Other flags off */
184 static int open_dmap(struct audio_operations
*adev
, int mode
, struct dma_buffparms
*dmap
)
188 if (dmap
->flags
& DMA_BUSY
)
190 if ((err
= sound_alloc_dmap(dmap
)) < 0)
193 if (dmap
->raw_buf
== NULL
) {
194 printk(KERN_WARNING
"Sound: DMA buffers not available\n");
195 return -ENOSPC
; /* Memory allocation failed during boot */
197 if (dmap
->dma
>= 0 && sound_open_dma(dmap
->dma
, adev
->name
)) {
198 printk(KERN_WARNING
"Unable to grab(2) DMA%d for the audio driver\n", dmap
->dma
);
201 dma_init_buffers(dmap
);
202 dmap
->open_mode
= mode
;
203 dmap
->subdivision
= dmap
->underrun_count
= 0;
204 dmap
->fragment_size
= 0;
205 dmap
->max_fragments
= 65536; /* Just a large value */
206 dmap
->byte_counter
= 0;
207 dmap
->max_byte_counter
= 8000 * 60 * 60;
208 dmap
->applic_profile
= APF_NORMAL
;
209 dmap
->needs_reorg
= 1;
210 dmap
->audio_callback
= NULL
;
211 dmap
->callback_parm
= 0;
215 static void close_dmap(struct audio_operations
*adev
, struct dma_buffparms
*dmap
)
219 if (dmap
->dma
>= 0) {
220 sound_close_dma(dmap
->dma
);
221 flags
=claim_dma_lock();
222 disable_dma(dmap
->dma
);
223 release_dma_lock(flags
);
225 if (dmap
->flags
& DMA_BUSY
)
226 dmap
->dma_mode
= DMODE_NONE
;
227 dmap
->flags
&= ~DMA_BUSY
;
229 if (sound_dmap_flag
== DMAP_FREE_ON_CLOSE
)
230 sound_free_dmap(dmap
);
234 static unsigned int default_set_bits(int dev
, unsigned int bits
)
236 mm_segment_t fs
= get_fs();
239 audio_devs
[dev
]->d
->ioctl(dev
, SNDCTL_DSP_SETFMT
, (caddr_t
)&bits
);
244 static int default_set_speed(int dev
, int speed
)
246 mm_segment_t fs
= get_fs();
249 audio_devs
[dev
]->d
->ioctl(dev
, SNDCTL_DSP_SPEED
, (caddr_t
)&speed
);
254 static short default_set_channels(int dev
, short channels
)
257 mm_segment_t fs
= get_fs();
260 audio_devs
[dev
]->d
->ioctl(dev
, SNDCTL_DSP_CHANNELS
, (caddr_t
)&c
);
265 static void check_driver(struct audio_driver
*d
)
267 if (d
->set_speed
== NULL
)
268 d
->set_speed
= default_set_speed
;
269 if (d
->set_bits
== NULL
)
270 d
->set_bits
= default_set_bits
;
271 if (d
->set_channels
== NULL
)
272 d
->set_channels
= default_set_channels
;
275 int DMAbuf_open(int dev
, int mode
)
277 struct audio_operations
*adev
= audio_devs
[dev
];
279 struct dma_buffparms
*dmap_in
= NULL
;
280 struct dma_buffparms
*dmap_out
= NULL
;
284 if (!(adev
->flags
& DMA_DUPLEX
))
285 adev
->dmap_in
= adev
->dmap_out
;
286 check_driver(adev
->d
);
288 if ((retval
= adev
->d
->open(dev
, mode
)) < 0)
290 dmap_out
= adev
->dmap_out
;
291 dmap_in
= adev
->dmap_in
;
292 if (dmap_in
== dmap_out
)
293 adev
->flags
&= ~DMA_DUPLEX
;
295 if (mode
& OPEN_WRITE
) {
296 if ((retval
= open_dmap(adev
, mode
, dmap_out
)) < 0) {
301 adev
->enable_bits
= mode
;
303 if (mode
== OPEN_READ
|| (mode
!= OPEN_WRITE
&& (adev
->flags
& DMA_DUPLEX
))) {
304 if ((retval
= open_dmap(adev
, mode
, dmap_in
)) < 0) {
306 if (mode
& OPEN_WRITE
)
307 close_dmap(adev
, dmap_out
);
311 adev
->open_mode
= mode
;
314 adev
->d
->set_bits(dev
, 8);
315 adev
->d
->set_channels(dev
, 1);
316 adev
->d
->set_speed(dev
, DSP_DEFAULT_SPEED
);
317 if (adev
->dmap_out
->dma_mode
== DMODE_OUTPUT
)
318 memset(adev
->dmap_out
->raw_buf
, adev
->dmap_out
->neutral_byte
,
319 adev
->dmap_out
->bytes_in_use
);
323 void DMAbuf_reset(int dev
)
325 if (audio_devs
[dev
]->open_mode
& OPEN_WRITE
)
326 dma_reset_output(dev
);
328 if (audio_devs
[dev
]->open_mode
& OPEN_READ
)
329 dma_reset_input(dev
);
332 static void dma_reset_output(int dev
)
334 struct audio_operations
*adev
= audio_devs
[dev
];
335 unsigned long flags
,f
;
336 struct dma_buffparms
*dmap
= adev
->dmap_out
;
338 if (!(dmap
->flags
& DMA_STARTED
)) /* DMA is not active */
342 * First wait until the current fragment has been played completely
346 adev
->dmap_out
->flags
|= DMA_SYNCING
;
348 adev
->dmap_out
->underrun_count
= 0;
349 if (!signal_pending(current
) && adev
->dmap_out
->qlen
&&
350 adev
->dmap_out
->underrun_count
== 0)
351 interruptible_sleep_on_timeout(&adev
->out_sleeper
,
352 dmabuf_timeout(dmap
));
353 adev
->dmap_out
->flags
&= ~(DMA_SYNCING
| DMA_ACTIVE
);
356 * Finally shut the device off
358 if (!(adev
->flags
& DMA_DUPLEX
) || !adev
->d
->halt_output
)
359 adev
->d
->halt_io(dev
);
361 adev
->d
->halt_output(dev
);
362 adev
->dmap_out
->flags
&= ~DMA_STARTED
;
365 clear_dma_ff(dmap
->dma
);
366 disable_dma(dmap
->dma
);
369 restore_flags(flags
);
370 dmap
->byte_counter
= 0;
371 reorganize_buffers(dev
, adev
->dmap_out
, 0);
372 dmap
->qlen
= dmap
->qhead
= dmap
->qtail
= dmap
->user_counter
= 0;
375 static void dma_reset_input(int dev
)
377 struct audio_operations
*adev
= audio_devs
[dev
];
379 struct dma_buffparms
*dmap
= adev
->dmap_in
;
383 if (!(adev
->flags
& DMA_DUPLEX
) || !adev
->d
->halt_input
)
384 adev
->d
->halt_io(dev
);
386 adev
->d
->halt_input(dev
);
387 adev
->dmap_in
->flags
&= ~DMA_STARTED
;
388 restore_flags(flags
);
390 dmap
->qlen
= dmap
->qhead
= dmap
->qtail
= dmap
->user_counter
= 0;
391 dmap
->byte_counter
= 0;
392 reorganize_buffers(dev
, adev
->dmap_in
, 1);
395 void DMAbuf_launch_output(int dev
, struct dma_buffparms
*dmap
)
397 struct audio_operations
*adev
= audio_devs
[dev
];
399 if (!((adev
->enable_bits
* adev
->go
) & PCM_ENABLE_OUTPUT
))
400 return; /* Don't start DMA yet */
401 dmap
->dma_mode
= DMODE_OUTPUT
;
403 if (!(dmap
->flags
& DMA_ACTIVE
) || !(adev
->flags
& DMA_AUTOMODE
) || (dmap
->flags
& DMA_NODMA
)) {
404 if (!(dmap
->flags
& DMA_STARTED
)) {
405 reorganize_buffers(dev
, dmap
, 0);
406 if (adev
->d
->prepare_for_output(dev
, dmap
->fragment_size
, dmap
->nbufs
))
408 if (!(dmap
->flags
& DMA_NODMA
))
409 local_start_dma(adev
, dmap
->raw_buf_phys
, dmap
->bytes_in_use
,DMA_MODE_WRITE
);
410 dmap
->flags
|= DMA_STARTED
;
412 if (dmap
->counts
[dmap
->qhead
] == 0)
413 dmap
->counts
[dmap
->qhead
] = dmap
->fragment_size
;
414 dmap
->dma_mode
= DMODE_OUTPUT
;
415 adev
->d
->output_block(dev
, dmap
->raw_buf_phys
+ dmap
->qhead
* dmap
->fragment_size
,
416 dmap
->counts
[dmap
->qhead
], 1);
417 if (adev
->d
->trigger
)
418 adev
->d
->trigger(dev
,adev
->enable_bits
* adev
->go
);
420 dmap
->flags
|= DMA_ACTIVE
;
423 int DMAbuf_sync(int dev
)
425 struct audio_operations
*adev
= audio_devs
[dev
];
428 struct dma_buffparms
*dmap
;
430 if (!adev
->go
&& !(adev
->enable_bits
& PCM_ENABLE_OUTPUT
))
433 if (adev
->dmap_out
->dma_mode
== DMODE_OUTPUT
) {
434 dmap
= adev
->dmap_out
;
437 if (dmap
->qlen
> 0 && !(dmap
->flags
& DMA_ACTIVE
))
438 DMAbuf_launch_output(dev
, dmap
);
439 adev
->dmap_out
->flags
|= DMA_SYNCING
;
440 adev
->dmap_out
->underrun_count
= 0;
441 while (!signal_pending(current
) && n
++ <= adev
->dmap_out
->nbufs
&&
442 adev
->dmap_out
->qlen
&& adev
->dmap_out
->underrun_count
== 0) {
443 long t
= dmabuf_timeout(dmap
);
444 t
= interruptible_sleep_on_timeout(&adev
->out_sleeper
,
447 adev
->dmap_out
->flags
&= ~DMA_SYNCING
;
448 restore_flags(flags
);
449 return adev
->dmap_out
->qlen
;
452 adev
->dmap_out
->flags
&= ~(DMA_SYNCING
| DMA_ACTIVE
);
453 restore_flags(flags
);
456 * Some devices such as GUS have huge amount of on board RAM for the
457 * audio data. We have to wait until the device has finished playing.
462 if (adev
->d
->local_qlen
) { /* Device has hidden buffers */
463 while (!signal_pending(current
) &&
464 adev
->d
->local_qlen(dev
))
465 interruptible_sleep_on_timeout(&adev
->out_sleeper
,
466 dmabuf_timeout(dmap
));
468 restore_flags(flags
);
470 adev
->dmap_out
->dma_mode
= DMODE_NONE
;
471 return adev
->dmap_out
->qlen
;
474 int DMAbuf_release(int dev
, int mode
)
476 struct audio_operations
*adev
= audio_devs
[dev
];
479 if (adev
->open_mode
& OPEN_WRITE
)
480 adev
->dmap_out
->closing
= 1;
481 if (adev
->open_mode
& OPEN_READ
)
482 adev
->dmap_in
->closing
= 1;
484 if (adev
->open_mode
& OPEN_WRITE
)
485 if (!(adev
->dmap_out
->mapping_flags
& DMA_MAP_MAPPED
))
486 if (!signal_pending(current
) && (adev
->dmap_out
->dma_mode
== DMODE_OUTPUT
))
488 if (adev
->dmap_out
->dma_mode
== DMODE_OUTPUT
)
489 memset(adev
->dmap_out
->raw_buf
, adev
->dmap_out
->neutral_byte
, adev
->dmap_out
->bytes_in_use
);
496 if (adev
->open_mode
& OPEN_WRITE
)
497 close_dmap(adev
, adev
->dmap_out
);
499 if (adev
->open_mode
== OPEN_READ
||
500 (adev
->open_mode
!= OPEN_WRITE
&&
501 (adev
->flags
& DMA_DUPLEX
)))
502 close_dmap(adev
, adev
->dmap_in
);
504 restore_flags(flags
);
508 int DMAbuf_activate_recording(int dev
, struct dma_buffparms
*dmap
)
510 struct audio_operations
*adev
= audio_devs
[dev
];
513 if (!(adev
->open_mode
& OPEN_READ
))
515 if (!(adev
->enable_bits
& PCM_ENABLE_INPUT
))
517 if (dmap
->dma_mode
== DMODE_OUTPUT
) { /* Direction change */
520 dmap
->dma_mode
= DMODE_NONE
;
522 if (!dmap
->dma_mode
) {
523 reorganize_buffers(dev
, dmap
, 1);
524 if ((err
= adev
->d
->prepare_for_input(dev
,
525 dmap
->fragment_size
, dmap
->nbufs
)) < 0)
527 dmap
->dma_mode
= DMODE_INPUT
;
529 if (!(dmap
->flags
& DMA_ACTIVE
)) {
530 if (dmap
->needs_reorg
)
531 reorganize_buffers(dev
, dmap
, 0);
532 local_start_dma(adev
, dmap
->raw_buf_phys
, dmap
->bytes_in_use
, DMA_MODE_READ
);
533 adev
->d
->start_input(dev
, dmap
->raw_buf_phys
+ dmap
->qtail
* dmap
->fragment_size
,
534 dmap
->fragment_size
, 0);
535 dmap
->flags
|= DMA_ACTIVE
;
536 if (adev
->d
->trigger
)
537 adev
->d
->trigger(dev
, adev
->enable_bits
* adev
->go
);
542 int DMAbuf_getrdbuffer(int dev
, char **buf
, int *len
, int dontblock
)
544 struct audio_operations
*adev
= audio_devs
[dev
];
547 struct dma_buffparms
*dmap
= adev
->dmap_in
;
550 if (!(adev
->open_mode
& OPEN_READ
))
552 if (dmap
->needs_reorg
)
553 reorganize_buffers(dev
, dmap
, 0);
556 if (adev
->dmap_in
->mapping_flags
& DMA_MAP_MAPPED
) {
557 /* printk(KERN_WARNING "Sound: Can't read from mmapped device (1)\n");*/
558 restore_flags(flags
);
560 } else while (dmap
->qlen
<= 0 && n
++ < 10) {
561 long timeout
= MAX_SCHEDULE_TIMEOUT
;
562 if (!(adev
->enable_bits
& PCM_ENABLE_INPUT
) || !adev
->go
) {
563 restore_flags(flags
);
566 if ((err
= DMAbuf_activate_recording(dev
, dmap
)) < 0) {
567 restore_flags(flags
);
570 /* Wait for the next block */
573 restore_flags(flags
);
577 timeout
= dmabuf_timeout(dmap
);
578 timeout
= interruptible_sleep_on_timeout(&adev
->in_sleeper
,
581 /* FIXME: include device name */
583 printk(KERN_WARNING
"Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
584 dma_reset_input(dev
);
588 restore_flags(flags
);
591 return err
? err
: -EINTR
;
592 *buf
= &dmap
->raw_buf
[dmap
->qhead
* dmap
->fragment_size
+ dmap
->counts
[dmap
->qhead
]];
593 *len
= dmap
->fragment_size
- dmap
->counts
[dmap
->qhead
];
598 int DMAbuf_rmchars(int dev
, int buff_no
, int c
)
600 struct audio_operations
*adev
= audio_devs
[dev
];
601 struct dma_buffparms
*dmap
= adev
->dmap_in
;
602 int p
= dmap
->counts
[dmap
->qhead
] + c
;
604 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
)
606 /* printk("Sound: Can't read from mmapped device (2)\n");*/
609 else if (dmap
->qlen
<= 0)
611 else if (p
>= dmap
->fragment_size
) { /* This buffer is completely empty */
612 dmap
->counts
[dmap
->qhead
] = 0;
614 dmap
->qhead
= (dmap
->qhead
+ 1) % dmap
->nbufs
;
616 else dmap
->counts
[dmap
->qhead
] = p
;
621 int DMAbuf_get_buffer_pointer(int dev
, struct dma_buffparms
*dmap
, int direction
)
624 * Try to approximate the active byte position of the DMA pointer within the
625 * buffer area as well as possible.
634 if (!(dmap
->flags
& DMA_ACTIVE
))
637 int chan
= dmap
->dma
;
642 if(!isa_dma_bridge_buggy
)
643 disable_dma(dmap
->dma
);
645 pos
= get_dma_residue(chan
);
647 pos
= dmap
->bytes_in_use
- pos
;
649 if (!(dmap
->mapping_flags
& DMA_MAP_MAPPED
)) {
650 if (direction
== DMODE_OUTPUT
) {
651 if (dmap
->qhead
== 0)
652 if (pos
> dmap
->fragment_size
)
655 if (dmap
->qtail
== 0)
656 if (pos
> dmap
->fragment_size
)
662 if (pos
>= dmap
->bytes_in_use
)
665 if(!isa_dma_bridge_buggy
)
666 enable_dma(dmap
->dma
);
670 restore_flags(flags
);
671 /* printk( "%04x ", pos); */
677 * DMAbuf_start_devices() is called by the /dev/music driver to start
678 * one or more audio devices at desired moment.
681 void DMAbuf_start_devices(unsigned int devmask
)
683 struct audio_operations
*adev
;
686 for (dev
= 0; dev
< num_audiodevs
; dev
++) {
687 if (!(devmask
& (1 << dev
)))
689 if (!(adev
= audio_devs
[dev
]))
691 if (adev
->open_mode
== 0)
695 /* OK to start the device */
697 if (adev
->d
->trigger
)
698 adev
->d
->trigger(dev
,adev
->enable_bits
* adev
->go
);
702 int DMAbuf_space_in_queue(int dev
)
704 struct audio_operations
*adev
= audio_devs
[dev
];
706 struct dma_buffparms
*dmap
= adev
->dmap_out
;
707 int lim
= dmap
->nbufs
;
712 if (dmap
->qlen
>= lim
) /* No space at all */
716 * Verify that there are no more pending buffers than the limit
717 * defined by the process.
720 max
= dmap
->max_fragments
;
725 if (adev
->d
->local_qlen
) {
726 tmp
= adev
->d
->local_qlen(dev
);
728 tmp
--; /* This buffer has been counted twice */
731 if (dmap
->byte_counter
% dmap
->fragment_size
) /* There is a partial fragment */
739 static int output_sleep(int dev
, int dontblock
)
741 struct audio_operations
*adev
= audio_devs
[dev
];
743 struct dma_buffparms
*dmap
= adev
->dmap_out
;
749 if (!(adev
->enable_bits
& PCM_ENABLE_OUTPUT
))
753 * Wait for free space
755 if (signal_pending(current
))
757 timeout
= (adev
->go
&& !(dmap
->flags
& DMA_NOTIMEOUT
));
759 timeout_value
= dmabuf_timeout(dmap
);
761 timeout_value
= MAX_SCHEDULE_TIMEOUT
;
762 timeout_value
= interruptible_sleep_on_timeout(&adev
->out_sleeper
,
764 if (timeout
!= MAX_SCHEDULE_TIMEOUT
&& !timeout_value
) {
765 printk(KERN_WARNING
"Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
766 dma_reset_output(dev
);
768 if (signal_pending(current
))
774 static int find_output_space(int dev
, char **buf
, int *size
)
776 struct audio_operations
*adev
= audio_devs
[dev
];
777 struct dma_buffparms
*dmap
= adev
->dmap_out
;
779 unsigned long active_offs
;
782 int occupied_bytes
= (dmap
->user_counter
% dmap
->fragment_size
);
784 *buf
= dmap
->raw_buf
;
785 if (!(maxfrags
= DMAbuf_space_in_queue(dev
)) && !occupied_bytes
)
790 #ifdef BE_CONSERVATIVE
791 active_offs
= dmap
->byte_counter
+ dmap
->qhead
* dmap
->fragment_size
;
793 active_offs
= DMAbuf_get_buffer_pointer(dev
, dmap
, DMODE_OUTPUT
);
794 /* Check for pointer wrapping situation */
795 if (active_offs
< 0 || active_offs
>= dmap
->bytes_in_use
)
797 active_offs
+= dmap
->byte_counter
;
800 offs
= (dmap
->user_counter
% dmap
->bytes_in_use
) & ~SAMPLE_ROUNDUP
;
801 if (offs
< 0 || offs
>= dmap
->bytes_in_use
) {
802 restore_flags(flags
);
803 printk(KERN_ERR
"Sound: Got unexpected offs %ld. Giving up.\n", offs
);
804 printk("Counter = %ld, bytes=%d\n", dmap
->user_counter
, dmap
->bytes_in_use
);
807 *buf
= dmap
->raw_buf
+ offs
;
809 len
= active_offs
+ dmap
->bytes_in_use
- dmap
->user_counter
; /* Number of unused bytes in buffer */
811 if ((offs
+ len
) > dmap
->bytes_in_use
)
812 len
= dmap
->bytes_in_use
- offs
;
814 restore_flags(flags
);
817 if (len
> ((maxfrags
* dmap
->fragment_size
) - occupied_bytes
))
818 len
= (maxfrags
* dmap
->fragment_size
) - occupied_bytes
;
819 *size
= len
& ~SAMPLE_ROUNDUP
;
820 restore_flags(flags
);
824 int DMAbuf_getwrbuffer(int dev
, char **buf
, int *size
, int dontblock
)
826 struct audio_operations
*adev
= audio_devs
[dev
];
829 struct dma_buffparms
*dmap
= adev
->dmap_out
;
831 if (dmap
->needs_reorg
)
832 reorganize_buffers(dev
, dmap
, 0);
834 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
) {
835 /* printk(KERN_DEBUG "Sound: Can't write to mmapped device (3)\n");*/
838 if (dmap
->dma_mode
== DMODE_INPUT
) { /* Direction change */
840 dmap
->dma_mode
= DMODE_NONE
;
842 dmap
->dma_mode
= DMODE_OUTPUT
;
846 while (find_output_space(dev
, buf
, size
) <= 0) {
847 if ((err
= output_sleep(dev
, dontblock
)) < 0) {
848 restore_flags(flags
);
852 restore_flags(flags
);
857 int DMAbuf_move_wrpointer(int dev
, int l
)
859 struct audio_operations
*adev
= audio_devs
[dev
];
860 struct dma_buffparms
*dmap
= adev
->dmap_out
;
861 unsigned long ptr
= (dmap
->user_counter
/ dmap
->fragment_size
) * dmap
->fragment_size
;
862 unsigned long end_ptr
, p
;
863 int post
= (dmap
->flags
& DMA_POST
);
865 dmap
->flags
&= ~DMA_POST
;
867 dmap
->user_counter
+= l
;
868 dmap
->flags
|= DMA_DIRTY
;
870 if (dmap
->byte_counter
>= dmap
->max_byte_counter
) {
871 /* Wrap the byte counters */
872 long decr
= dmap
->byte_counter
;
873 dmap
->byte_counter
= (dmap
->byte_counter
% dmap
->bytes_in_use
);
874 decr
-= dmap
->byte_counter
;
875 dmap
->user_counter
-= decr
;
877 end_ptr
= (dmap
->user_counter
/ dmap
->fragment_size
) * dmap
->fragment_size
;
879 p
= (dmap
->user_counter
- 1) % dmap
->bytes_in_use
;
880 dmap
->neutral_byte
= dmap
->raw_buf
[p
];
882 /* Update the fragment based bookkeeping too */
883 while (ptr
< end_ptr
) {
884 dmap
->counts
[dmap
->qtail
] = dmap
->fragment_size
;
885 dmap
->qtail
= (dmap
->qtail
+ 1) % dmap
->nbufs
;
887 ptr
+= dmap
->fragment_size
;
890 dmap
->counts
[dmap
->qtail
] = dmap
->user_counter
- ptr
;
893 * Let the low level driver to perform some postprocessing to
896 if (adev
->d
->postprocess_write
)
897 adev
->d
->postprocess_write(dev
);
899 if (!(dmap
->flags
& DMA_ACTIVE
))
900 if (dmap
->qlen
> 1 || (dmap
->qlen
> 0 && (post
|| dmap
->qlen
>= dmap
->nbufs
- 1)))
901 DMAbuf_launch_output(dev
, dmap
);
905 int DMAbuf_start_dma(int dev
, unsigned long physaddr
, int count
, int dma_mode
)
907 struct audio_operations
*adev
= audio_devs
[dev
];
908 struct dma_buffparms
*dmap
= (dma_mode
== DMA_MODE_WRITE
) ? adev
->dmap_out
: adev
->dmap_in
;
910 if (dmap
->raw_buf
== NULL
) {
911 printk(KERN_ERR
"sound: DMA buffer(1) == NULL\n");
912 printk("Device %d, chn=%s\n", dev
, (dmap
== adev
->dmap_out
) ? "out" : "in");
917 sound_start_dma(dmap
, physaddr
, count
, dma_mode
);
921 static int local_start_dma(struct audio_operations
*adev
, unsigned long physaddr
, int count
, int dma_mode
)
923 struct dma_buffparms
*dmap
= (dma_mode
== DMA_MODE_WRITE
) ? adev
->dmap_out
: adev
->dmap_in
;
925 if (dmap
->raw_buf
== NULL
) {
926 printk(KERN_ERR
"sound: DMA buffer(2) == NULL\n");
927 printk(KERN_ERR
"Device %s, chn=%s\n", adev
->name
, (dmap
== adev
->dmap_out
) ? "out" : "in");
930 if (dmap
->flags
& DMA_NODMA
)
934 sound_start_dma(dmap
, dmap
->raw_buf_phys
, dmap
->bytes_in_use
, dma_mode
| DMA_AUTOINIT
);
935 dmap
->flags
|= DMA_STARTED
;
939 static void finish_output_interrupt(int dev
, struct dma_buffparms
*dmap
)
941 struct audio_operations
*adev
= audio_devs
[dev
];
943 if (dmap
->audio_callback
!= NULL
)
944 dmap
->audio_callback(dev
, dmap
->callback_parm
);
945 wake_up(&adev
->out_sleeper
);
946 wake_up(&adev
->poll_sleeper
);
949 static void do_outputintr(int dev
, int dummy
)
951 struct audio_operations
*adev
= audio_devs
[dev
];
953 struct dma_buffparms
*dmap
= adev
->dmap_out
;
956 if (dmap
->raw_buf
== NULL
) {
957 printk(KERN_ERR
"Sound: Error. Audio interrupt (%d) after freeing buffers.\n", dev
);
960 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
) { /* Virtual memory mapped access */
962 dmap
->qhead
= (dmap
->qhead
+ 1) % dmap
->nbufs
;
963 if (dmap
->qhead
== 0) { /* Wrapped */
964 dmap
->byte_counter
+= dmap
->bytes_in_use
;
965 if (dmap
->byte_counter
>= dmap
->max_byte_counter
) { /* Overflow */
966 long decr
= dmap
->byte_counter
;
967 dmap
->byte_counter
= (dmap
->byte_counter
% dmap
->bytes_in_use
);
968 decr
-= dmap
->byte_counter
;
969 dmap
->user_counter
-= decr
;
972 dmap
->qlen
++; /* Yes increment it (don't decrement) */
973 if (!(adev
->flags
& DMA_AUTOMODE
))
974 dmap
->flags
&= ~DMA_ACTIVE
;
975 dmap
->counts
[dmap
->qhead
] = dmap
->fragment_size
;
976 DMAbuf_launch_output(dev
, dmap
);
977 finish_output_interrupt(dev
, dmap
);
984 this_fragment
= dmap
->qhead
;
985 dmap
->qhead
= (dmap
->qhead
+ 1) % dmap
->nbufs
;
987 if (dmap
->qhead
== 0) { /* Wrapped */
988 dmap
->byte_counter
+= dmap
->bytes_in_use
;
989 if (dmap
->byte_counter
>= dmap
->max_byte_counter
) { /* Overflow */
990 long decr
= dmap
->byte_counter
;
991 dmap
->byte_counter
= (dmap
->byte_counter
% dmap
->bytes_in_use
);
992 decr
-= dmap
->byte_counter
;
993 dmap
->user_counter
-= decr
;
996 if (!(adev
->flags
& DMA_AUTOMODE
))
997 dmap
->flags
&= ~DMA_ACTIVE
;
1000 * This is dmap->qlen <= 0 except when closing when
1004 while (dmap
->qlen
<= -dmap
->closing
) {
1005 dmap
->underrun_count
++;
1007 if ((dmap
->flags
& DMA_DIRTY
) && dmap
->applic_profile
!= APF_CPUINTENS
) {
1008 dmap
->flags
&= ~DMA_DIRTY
;
1009 memset(adev
->dmap_out
->raw_buf
, adev
->dmap_out
->neutral_byte
,
1010 adev
->dmap_out
->buffsize
);
1012 dmap
->user_counter
+= dmap
->fragment_size
;
1013 dmap
->qtail
= (dmap
->qtail
+ 1) % dmap
->nbufs
;
1016 DMAbuf_launch_output(dev
, dmap
);
1017 restore_flags(flags
);
1018 finish_output_interrupt(dev
, dmap
);
1021 void DMAbuf_outputintr(int dev
, int notify_only
)
1023 struct audio_operations
*adev
= audio_devs
[dev
];
1024 unsigned long flags
;
1025 struct dma_buffparms
*dmap
= adev
->dmap_out
;
1029 if (!(dmap
->flags
& DMA_NODMA
)) {
1030 int chan
= dmap
->dma
, pos
, n
;
1035 if(!isa_dma_bridge_buggy
)
1036 disable_dma(dmap
->dma
);
1038 pos
= dmap
->bytes_in_use
- get_dma_residue(chan
);
1039 if(!isa_dma_bridge_buggy
)
1040 enable_dma(dmap
->dma
);
1041 release_dma_lock(f
);
1043 pos
= pos
/ dmap
->fragment_size
; /* Actual qhead */
1044 if (pos
< 0 || pos
>= dmap
->nbufs
)
1047 while (dmap
->qhead
!= pos
&& n
++ < dmap
->nbufs
)
1048 do_outputintr(dev
, notify_only
);
1051 do_outputintr(dev
, notify_only
);
1052 restore_flags(flags
);
1055 static void do_inputintr(int dev
)
1057 struct audio_operations
*adev
= audio_devs
[dev
];
1058 struct dma_buffparms
*dmap
= adev
->dmap_in
;
1060 if (dmap
->raw_buf
== NULL
) {
1061 printk(KERN_ERR
"Sound: Fatal error. Audio interrupt after freeing buffers.\n");
1064 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
) {
1065 dmap
->qtail
= (dmap
->qtail
+ 1) % dmap
->nbufs
;
1066 if (dmap
->qtail
== 0) { /* Wrapped */
1067 dmap
->byte_counter
+= dmap
->bytes_in_use
;
1068 if (dmap
->byte_counter
>= dmap
->max_byte_counter
) { /* Overflow */
1069 long decr
= dmap
->byte_counter
;
1070 dmap
->byte_counter
= (dmap
->byte_counter
% dmap
->bytes_in_use
) + dmap
->bytes_in_use
;
1071 decr
-= dmap
->byte_counter
;
1072 dmap
->user_counter
-= decr
;
1077 if (!(adev
->flags
& DMA_AUTOMODE
)) {
1078 if (dmap
->needs_reorg
)
1079 reorganize_buffers(dev
, dmap
, 0);
1080 local_start_dma(adev
, dmap
->raw_buf_phys
, dmap
->bytes_in_use
,DMA_MODE_READ
);
1081 adev
->d
->start_input(dev
, dmap
->raw_buf_phys
+ dmap
->qtail
* dmap
->fragment_size
,
1082 dmap
->fragment_size
, 1);
1083 if (adev
->d
->trigger
)
1084 adev
->d
->trigger(dev
, adev
->enable_bits
* adev
->go
);
1086 dmap
->flags
|= DMA_ACTIVE
;
1087 } else if (dmap
->qlen
>= (dmap
->nbufs
- 1)) {
1088 printk(KERN_WARNING
"Sound: Recording overrun\n");
1089 dmap
->underrun_count
++;
1091 /* Just throw away the oldest fragment but keep the engine running */
1092 dmap
->qhead
= (dmap
->qhead
+ 1) % dmap
->nbufs
;
1093 dmap
->qtail
= (dmap
->qtail
+ 1) % dmap
->nbufs
;
1094 } else if (dmap
->qlen
>= 0 && dmap
->qlen
< dmap
->nbufs
) {
1096 dmap
->qtail
= (dmap
->qtail
+ 1) % dmap
->nbufs
;
1097 if (dmap
->qtail
== 0) { /* Wrapped */
1098 dmap
->byte_counter
+= dmap
->bytes_in_use
;
1099 if (dmap
->byte_counter
>= dmap
->max_byte_counter
) { /* Overflow */
1100 long decr
= dmap
->byte_counter
;
1101 dmap
->byte_counter
= (dmap
->byte_counter
% dmap
->bytes_in_use
) + dmap
->bytes_in_use
;
1102 decr
-= dmap
->byte_counter
;
1103 dmap
->user_counter
-= decr
;
1107 if (!(adev
->flags
& DMA_AUTOMODE
) || (dmap
->flags
& DMA_NODMA
)) {
1108 local_start_dma(adev
, dmap
->raw_buf_phys
, dmap
->bytes_in_use
, DMA_MODE_READ
);
1109 adev
->d
->start_input(dev
, dmap
->raw_buf_phys
+ dmap
->qtail
* dmap
->fragment_size
, dmap
->fragment_size
, 1);
1110 if (adev
->d
->trigger
)
1111 adev
->d
->trigger(dev
,adev
->enable_bits
* adev
->go
);
1113 dmap
->flags
|= DMA_ACTIVE
;
1116 wake_up(&adev
->in_sleeper
);
1117 wake_up(&adev
->poll_sleeper
);
1121 void DMAbuf_inputintr(int dev
)
1123 struct audio_operations
*adev
= audio_devs
[dev
];
1124 struct dma_buffparms
*dmap
= adev
->dmap_in
;
1125 unsigned long flags
;
1130 if (!(dmap
->flags
& DMA_NODMA
)) {
1131 int chan
= dmap
->dma
, pos
, n
;
1135 if(!isa_dma_bridge_buggy
)
1136 disable_dma(dmap
->dma
);
1138 pos
= dmap
->bytes_in_use
- get_dma_residue(chan
);
1139 if(!isa_dma_bridge_buggy
)
1140 enable_dma(dmap
->dma
);
1141 release_dma_lock(f
);
1143 pos
= pos
/ dmap
->fragment_size
; /* Actual qhead */
1144 if (pos
< 0 || pos
>= dmap
->nbufs
)
1148 while (dmap
->qtail
!= pos
&& ++n
< dmap
->nbufs
)
1152 restore_flags(flags
);
1155 int DMAbuf_open_dma(int dev
)
1158 * NOTE! This routine opens only the primary DMA channel (output).
1160 struct audio_operations
*adev
= audio_devs
[dev
];
1163 if ((err
= open_dmap(adev
, OPEN_READWRITE
, adev
->dmap_out
)) < 0)
1165 dma_init_buffers(adev
->dmap_out
);
1166 adev
->dmap_out
->flags
|= DMA_ALLOC_DONE
;
1167 adev
->dmap_out
->fragment_size
= adev
->dmap_out
->buffsize
;
1169 if (adev
->dmap_out
->dma
>= 0) {
1170 unsigned long flags
;
1172 flags
=claim_dma_lock();
1173 clear_dma_ff(adev
->dmap_out
->dma
);
1174 disable_dma(adev
->dmap_out
->dma
);
1175 release_dma_lock(flags
);
1180 void DMAbuf_close_dma(int dev
)
1182 close_dmap(audio_devs
[dev
], audio_devs
[dev
]->dmap_out
);
1185 void DMAbuf_init(int dev
, int dma1
, int dma2
)
1187 struct audio_operations
*adev
= audio_devs
[dev
];
1189 * NOTE! This routine could be called several times.
1192 /* drag in audio_syms.o */
1194 extern char audio_syms_symbol
;
1195 audio_syms_symbol
= 0;
1198 if (adev
&& adev
->dmap_out
== NULL
) {
1199 if (adev
->d
== NULL
)
1200 panic("OSS: audio_devs[%d]->d == NULL\n", dev
);
1202 if (adev
->parent_dev
) { /* Use DMA map of the parent dev */
1203 int parent
= adev
->parent_dev
- 1;
1204 adev
->dmap_out
= audio_devs
[parent
]->dmap_out
;
1205 adev
->dmap_in
= audio_devs
[parent
]->dmap_in
;
1207 adev
->dmap_out
= adev
->dmap_in
= &adev
->dmaps
[0];
1208 adev
->dmap_out
->dma
= dma1
;
1209 if (adev
->flags
& DMA_DUPLEX
) {
1210 adev
->dmap_in
= &adev
->dmaps
[1];
1211 adev
->dmap_in
->dma
= dma2
;
1214 /* Persistent DMA buffers allocated here */
1215 if (sound_dmap_flag
== DMAP_KEEP_ON_CLOSE
) {
1216 if (adev
->dmap_in
->raw_buf
== NULL
)
1217 sound_alloc_dmap(adev
->dmap_in
);
1218 if (adev
->dmap_out
->raw_buf
== NULL
)
1219 sound_alloc_dmap(adev
->dmap_out
);
1224 /* No kernel lock - DMAbuf_activate_recording protected by global cli/sti */
1225 static unsigned int poll_input(struct file
* file
, int dev
, poll_table
*wait
)
1227 struct audio_operations
*adev
= audio_devs
[dev
];
1228 struct dma_buffparms
*dmap
= adev
->dmap_in
;
1230 if (!(adev
->open_mode
& OPEN_READ
))
1232 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
) {
1234 return POLLIN
| POLLRDNORM
;
1237 if (dmap
->dma_mode
!= DMODE_INPUT
) {
1238 if (dmap
->dma_mode
== DMODE_NONE
&&
1239 adev
->enable_bits
& PCM_ENABLE_INPUT
&&
1240 !dmap
->qlen
&& adev
->go
) {
1241 unsigned long flags
;
1245 DMAbuf_activate_recording(dev
, dmap
);
1246 restore_flags(flags
);
1252 return POLLIN
| POLLRDNORM
;
1255 static unsigned int poll_output(struct file
* file
, int dev
, poll_table
*wait
)
1257 struct audio_operations
*adev
= audio_devs
[dev
];
1258 struct dma_buffparms
*dmap
= adev
->dmap_out
;
1260 if (!(adev
->open_mode
& OPEN_WRITE
))
1262 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
) {
1264 return POLLOUT
| POLLWRNORM
;
1267 if (dmap
->dma_mode
== DMODE_INPUT
)
1269 if (dmap
->dma_mode
== DMODE_NONE
)
1270 return POLLOUT
| POLLWRNORM
;
1271 if (!DMAbuf_space_in_queue(dev
))
1273 return POLLOUT
| POLLWRNORM
;
1276 unsigned int DMAbuf_poll(struct file
* file
, int dev
, poll_table
*wait
)
1278 struct audio_operations
*adev
= audio_devs
[dev
];
1279 poll_wait(file
, &adev
->poll_sleeper
, wait
);
1280 return poll_input(file
, dev
, wait
) | poll_output(file
, dev
, wait
);
1283 void DMAbuf_deinit(int dev
)
1285 struct audio_operations
*adev
= audio_devs
[dev
];
1286 /* This routine is called when driver is being unloaded */
1290 /* Persistent DMA buffers deallocated here */
1291 if (sound_dmap_flag
== DMAP_KEEP_ON_CLOSE
) {
1292 sound_free_dmap(adev
->dmap_out
);
1293 if (adev
->flags
& DMA_DUPLEX
)
1294 sound_free_dmap(adev
->dmap_in
);