Loading...
Note: File does not exist in v5.9.
1/*
2 * sound/oss/dmabuf.c
3 *
4 * The DMA buffer manager for digitized voice applications
5 */
6/*
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
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
11 * for more info.
12 *
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
16 * 12k or so
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.
21 *
22 * Rob Riggs Added persistent DMA buffers (1998/10/17)
23 */
24
25#define BE_CONSERVATIVE
26#define SAMPLE_ROUNDUP 0
27
28#include <linux/mm.h>
29#include <linux/gfp.h>
30#include "sound_config.h"
31#include "sleep.h"
32
33#define DMAP_FREE_ON_CLOSE 0
34#define DMAP_KEEP_ON_CLOSE 1
35extern int sound_dmap_flag;
36
37static void dma_reset_output(int dev);
38static void dma_reset_input(int dev);
39static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode);
40
41
42
43static int debugmem; /* switched off by default */
44static int dma_buffsize = DSP_BUFFSIZE;
45
46static long dmabuf_timeout(struct dma_buffparms *dmap)
47{
48 long tmout;
49
50 tmout = (dmap->fragment_size * HZ) / dmap->data_rate;
51 tmout += HZ / 5; /* Some safety distance */
52 if (tmout < (HZ / 2))
53 tmout = HZ / 2;
54 if (tmout > 20 * HZ)
55 tmout = 20 * HZ;
56 return tmout;
57}
58
59static int sound_alloc_dmap(struct dma_buffparms *dmap)
60{
61 char *start_addr, *end_addr;
62 int dma_pagesize;
63 int sz, size;
64 struct page *page;
65
66 dmap->mapping_flags &= ~DMA_MAP_MAPPED;
67
68 if (dmap->raw_buf != NULL)
69 return 0; /* Already done */
70 if (dma_buffsize < 4096)
71 dma_buffsize = 4096;
72 dma_pagesize = (dmap->dma < 4) ? (64 * 1024) : (128 * 1024);
73
74 /*
75 * Now check for the Cyrix problem.
76 */
77
78 if(isa_dma_bridge_buggy==2)
79 dma_pagesize=32768;
80
81 dmap->raw_buf = NULL;
82 dmap->buffsize = dma_buffsize;
83 if (dmap->buffsize > dma_pagesize)
84 dmap->buffsize = dma_pagesize;
85 start_addr = NULL;
86 /*
87 * Now loop until we get a free buffer. Try to get smaller buffer if
88 * it fails. Don't accept smaller than 8k buffer for performance
89 * reasons.
90 */
91 while (start_addr == NULL && dmap->buffsize > PAGE_SIZE) {
92 for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
93 dmap->buffsize = PAGE_SIZE * (1 << sz);
94 start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA|__GFP_NOWARN, sz);
95 if (start_addr == NULL)
96 dmap->buffsize /= 2;
97 }
98
99 if (start_addr == NULL) {
100 printk(KERN_WARNING "Sound error: Couldn't allocate DMA buffer\n");
101 return -ENOMEM;
102 } else {
103 /* make some checks */
104 end_addr = start_addr + dmap->buffsize - 1;
105
106 if (debugmem)
107 printk(KERN_DEBUG "sound: start 0x%lx, end 0x%lx\n", (long) start_addr, (long) end_addr);
108
109 /* now check if it fits into the same dma-pagesize */
110
111 if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
112 || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
113 printk(KERN_ERR "sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, dmap->buffsize);
114 return -EFAULT;
115 }
116 }
117 dmap->raw_buf = start_addr;
118 dmap->raw_buf_phys = dma_map_single(NULL, start_addr, dmap->buffsize, DMA_BIDIRECTIONAL);
119
120 for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
121 SetPageReserved(page);
122 return 0;
123}
124
125static void sound_free_dmap(struct dma_buffparms *dmap)
126{
127 int sz, size;
128 struct page *page;
129 unsigned long start_addr, end_addr;
130
131 if (dmap->raw_buf == NULL)
132 return;
133 if (dmap->mapping_flags & DMA_MAP_MAPPED)
134 return; /* Don't free mmapped buffer. Will use it next time */
135 for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
136
137 start_addr = (unsigned long) dmap->raw_buf;
138 end_addr = start_addr + dmap->buffsize;
139
140 for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
141 ClearPageReserved(page);
142
143 dma_unmap_single(NULL, dmap->raw_buf_phys, dmap->buffsize, DMA_BIDIRECTIONAL);
144 free_pages((unsigned long) dmap->raw_buf, sz);
145 dmap->raw_buf = NULL;
146}
147
148
149/* Intel version !!!!!!!!! */
150
151static int sound_start_dma(struct dma_buffparms *dmap, unsigned long physaddr, int count, int dma_mode)
152{
153 unsigned long flags;
154 int chan = dmap->dma;
155
156 /* printk( "Start DMA%d %d, %d\n", chan, (int)(physaddr-dmap->raw_buf_phys), count); */
157
158 flags = claim_dma_lock();
159 disable_dma(chan);
160 clear_dma_ff(chan);
161 set_dma_mode(chan, dma_mode);
162 set_dma_addr(chan, physaddr);
163 set_dma_count(chan, count);
164 enable_dma(chan);
165 release_dma_lock(flags);
166
167 return 0;
168}
169
170static void dma_init_buffers(struct dma_buffparms *dmap)
171{
172 dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
173 dmap->byte_counter = 0;
174 dmap->max_byte_counter = 8000 * 60 * 60;
175 dmap->bytes_in_use = dmap->buffsize;
176
177 dmap->dma_mode = DMODE_NONE;
178 dmap->mapping_flags = 0;
179 dmap->neutral_byte = 0x80;
180 dmap->data_rate = 8000;
181 dmap->cfrag = -1;
182 dmap->closing = 0;
183 dmap->nbufs = 1;
184 dmap->flags = DMA_BUSY; /* Other flags off */
185}
186
187static int open_dmap(struct audio_operations *adev, int mode, struct dma_buffparms *dmap)
188{
189 int err;
190
191 if (dmap->flags & DMA_BUSY)
192 return -EBUSY;
193 if ((err = sound_alloc_dmap(dmap)) < 0)
194 return err;
195
196 if (dmap->raw_buf == NULL) {
197 printk(KERN_WARNING "Sound: DMA buffers not available\n");
198 return -ENOSPC; /* Memory allocation failed during boot */
199 }
200 if (dmap->dma >= 0 && sound_open_dma(dmap->dma, adev->name)) {
201 printk(KERN_WARNING "Unable to grab(2) DMA%d for the audio driver\n", dmap->dma);
202 return -EBUSY;
203 }
204 dma_init_buffers(dmap);
205 spin_lock_init(&dmap->lock);
206 dmap->open_mode = mode;
207 dmap->subdivision = dmap->underrun_count = 0;
208 dmap->fragment_size = 0;
209 dmap->max_fragments = 65536; /* Just a large value */
210 dmap->byte_counter = 0;
211 dmap->max_byte_counter = 8000 * 60 * 60;
212 dmap->applic_profile = APF_NORMAL;
213 dmap->needs_reorg = 1;
214 dmap->audio_callback = NULL;
215 dmap->callback_parm = 0;
216 return 0;
217}
218
219static void close_dmap(struct audio_operations *adev, struct dma_buffparms *dmap)
220{
221 unsigned long flags;
222
223 if (dmap->dma >= 0) {
224 sound_close_dma(dmap->dma);
225 flags=claim_dma_lock();
226 disable_dma(dmap->dma);
227 release_dma_lock(flags);
228 }
229 if (dmap->flags & DMA_BUSY)
230 dmap->dma_mode = DMODE_NONE;
231 dmap->flags &= ~DMA_BUSY;
232
233 if (sound_dmap_flag == DMAP_FREE_ON_CLOSE)
234 sound_free_dmap(dmap);
235}
236
237
238static unsigned int default_set_bits(int dev, unsigned int bits)
239{
240 mm_segment_t fs = get_fs();
241
242 set_fs(get_ds());
243 audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SETFMT, (void __user *)&bits);
244 set_fs(fs);
245 return bits;
246}
247
248static int default_set_speed(int dev, int speed)
249{
250 mm_segment_t fs = get_fs();
251
252 set_fs(get_ds());
253 audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SPEED, (void __user *)&speed);
254 set_fs(fs);
255 return speed;
256}
257
258static short default_set_channels(int dev, short channels)
259{
260 int c = channels;
261 mm_segment_t fs = get_fs();
262
263 set_fs(get_ds());
264 audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_CHANNELS, (void __user *)&c);
265 set_fs(fs);
266 return c;
267}
268
269static void check_driver(struct audio_driver *d)
270{
271 if (d->set_speed == NULL)
272 d->set_speed = default_set_speed;
273 if (d->set_bits == NULL)
274 d->set_bits = default_set_bits;
275 if (d->set_channels == NULL)
276 d->set_channels = default_set_channels;
277}
278
279int DMAbuf_open(int dev, int mode)
280{
281 struct audio_operations *adev = audio_devs[dev];
282 int retval;
283 struct dma_buffparms *dmap_in = NULL;
284 struct dma_buffparms *dmap_out = NULL;
285
286 if (!adev)
287 return -ENXIO;
288 if (!(adev->flags & DMA_DUPLEX))
289 adev->dmap_in = adev->dmap_out;
290 check_driver(adev->d);
291
292 if ((retval = adev->d->open(dev, mode)) < 0)
293 return retval;
294 dmap_out = adev->dmap_out;
295 dmap_in = adev->dmap_in;
296 if (dmap_in == dmap_out)
297 adev->flags &= ~DMA_DUPLEX;
298
299 if (mode & OPEN_WRITE) {
300 if ((retval = open_dmap(adev, mode, dmap_out)) < 0) {
301 adev->d->close(dev);
302 return retval;
303 }
304 }
305 adev->enable_bits = mode;
306
307 if (mode == OPEN_READ || (mode != OPEN_WRITE && (adev->flags & DMA_DUPLEX))) {
308 if ((retval = open_dmap(adev, mode, dmap_in)) < 0) {
309 adev->d->close(dev);
310 if (mode & OPEN_WRITE)
311 close_dmap(adev, dmap_out);
312 return retval;
313 }
314 }
315 adev->open_mode = mode;
316 adev->go = 1;
317
318 adev->d->set_bits(dev, 8);
319 adev->d->set_channels(dev, 1);
320 adev->d->set_speed(dev, DSP_DEFAULT_SPEED);
321 if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
322 memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
323 adev->dmap_out->bytes_in_use);
324 return 0;
325}
326/* MUST not hold the spinlock */
327void DMAbuf_reset(int dev)
328{
329 if (audio_devs[dev]->open_mode & OPEN_WRITE)
330 dma_reset_output(dev);
331
332 if (audio_devs[dev]->open_mode & OPEN_READ)
333 dma_reset_input(dev);
334}
335
336static void dma_reset_output(int dev)
337{
338 struct audio_operations *adev = audio_devs[dev];
339 unsigned long flags,f ;
340 struct dma_buffparms *dmap = adev->dmap_out;
341
342 if (!(dmap->flags & DMA_STARTED)) /* DMA is not active */
343 return;
344
345 /*
346 * First wait until the current fragment has been played completely
347 */
348 spin_lock_irqsave(&dmap->lock,flags);
349 adev->dmap_out->flags |= DMA_SYNCING;
350
351 adev->dmap_out->underrun_count = 0;
352 if (!signal_pending(current) && adev->dmap_out->qlen &&
353 adev->dmap_out->underrun_count == 0){
354 spin_unlock_irqrestore(&dmap->lock,flags);
355 oss_broken_sleep_on(&adev->out_sleeper, dmabuf_timeout(dmap));
356 spin_lock_irqsave(&dmap->lock,flags);
357 }
358 adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
359
360 /*
361 * Finally shut the device off
362 */
363 if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_output)
364 adev->d->halt_io(dev);
365 else
366 adev->d->halt_output(dev);
367 adev->dmap_out->flags &= ~DMA_STARTED;
368
369 f=claim_dma_lock();
370 clear_dma_ff(dmap->dma);
371 disable_dma(dmap->dma);
372 release_dma_lock(f);
373
374 dmap->byte_counter = 0;
375 reorganize_buffers(dev, adev->dmap_out, 0);
376 dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
377 spin_unlock_irqrestore(&dmap->lock,flags);
378}
379
380static void dma_reset_input(int dev)
381{
382 struct audio_operations *adev = audio_devs[dev];
383 unsigned long flags;
384 struct dma_buffparms *dmap = adev->dmap_in;
385
386 spin_lock_irqsave(&dmap->lock,flags);
387 if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_input)
388 adev->d->halt_io(dev);
389 else
390 adev->d->halt_input(dev);
391 adev->dmap_in->flags &= ~DMA_STARTED;
392
393 dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
394 dmap->byte_counter = 0;
395 reorganize_buffers(dev, adev->dmap_in, 1);
396 spin_unlock_irqrestore(&dmap->lock,flags);
397}
398/* MUST be called with holding the dmap->lock */
399void DMAbuf_launch_output(int dev, struct dma_buffparms *dmap)
400{
401 struct audio_operations *adev = audio_devs[dev];
402
403 if (!((adev->enable_bits * adev->go) & PCM_ENABLE_OUTPUT))
404 return; /* Don't start DMA yet */
405 dmap->dma_mode = DMODE_OUTPUT;
406
407 if (!(dmap->flags & DMA_ACTIVE) || !(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
408 if (!(dmap->flags & DMA_STARTED)) {
409 reorganize_buffers(dev, dmap, 0);
410 if (adev->d->prepare_for_output(dev, dmap->fragment_size, dmap->nbufs))
411 return;
412 if (!(dmap->flags & DMA_NODMA))
413 local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_WRITE);
414 dmap->flags |= DMA_STARTED;
415 }
416 if (dmap->counts[dmap->qhead] == 0)
417 dmap->counts[dmap->qhead] = dmap->fragment_size;
418 dmap->dma_mode = DMODE_OUTPUT;
419 adev->d->output_block(dev, dmap->raw_buf_phys + dmap->qhead * dmap->fragment_size,
420 dmap->counts[dmap->qhead], 1);
421 if (adev->d->trigger)
422 adev->d->trigger(dev,adev->enable_bits * adev->go);
423 }
424 dmap->flags |= DMA_ACTIVE;
425}
426
427int DMAbuf_sync(int dev)
428{
429 struct audio_operations *adev = audio_devs[dev];
430 unsigned long flags;
431 int n = 0;
432 struct dma_buffparms *dmap;
433
434 if (!adev->go && !(adev->enable_bits & PCM_ENABLE_OUTPUT))
435 return 0;
436
437 if (adev->dmap_out->dma_mode == DMODE_OUTPUT) {
438 dmap = adev->dmap_out;
439 spin_lock_irqsave(&dmap->lock,flags);
440 if (dmap->qlen > 0 && !(dmap->flags & DMA_ACTIVE))
441 DMAbuf_launch_output(dev, dmap);
442 adev->dmap_out->flags |= DMA_SYNCING;
443 adev->dmap_out->underrun_count = 0;
444 while (!signal_pending(current) && n++ < adev->dmap_out->nbufs &&
445 adev->dmap_out->qlen && adev->dmap_out->underrun_count == 0) {
446 long t = dmabuf_timeout(dmap);
447 spin_unlock_irqrestore(&dmap->lock,flags);
448 /* FIXME: not safe may miss events */
449 t = oss_broken_sleep_on(&adev->out_sleeper, t);
450 spin_lock_irqsave(&dmap->lock,flags);
451 if (!t) {
452 adev->dmap_out->flags &= ~DMA_SYNCING;
453 spin_unlock_irqrestore(&dmap->lock,flags);
454 return adev->dmap_out->qlen;
455 }
456 }
457 adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
458
459 /*
460 * Some devices such as GUS have huge amount of on board RAM for the
461 * audio data. We have to wait until the device has finished playing.
462 */
463
464 /* still holding the lock */
465 if (adev->d->local_qlen) { /* Device has hidden buffers */
466 while (!signal_pending(current) &&
467 adev->d->local_qlen(dev)){
468 spin_unlock_irqrestore(&dmap->lock,flags);
469 oss_broken_sleep_on(&adev->out_sleeper,
470 dmabuf_timeout(dmap));
471 spin_lock_irqsave(&dmap->lock,flags);
472 }
473 }
474 spin_unlock_irqrestore(&dmap->lock,flags);
475 }
476 adev->dmap_out->dma_mode = DMODE_NONE;
477 return adev->dmap_out->qlen;
478}
479
480int DMAbuf_release(int dev, int mode)
481{
482 struct audio_operations *adev = audio_devs[dev];
483 struct dma_buffparms *dmap;
484 unsigned long flags;
485
486 dmap = adev->dmap_out;
487 if (adev->open_mode & OPEN_WRITE)
488 adev->dmap_out->closing = 1;
489
490 if (adev->open_mode & OPEN_READ){
491 adev->dmap_in->closing = 1;
492 dmap = adev->dmap_in;
493 }
494 if (adev->open_mode & OPEN_WRITE)
495 if (!(adev->dmap_out->mapping_flags & DMA_MAP_MAPPED))
496 if (!signal_pending(current) && (adev->dmap_out->dma_mode == DMODE_OUTPUT))
497 DMAbuf_sync(dev);
498 if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
499 memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte, adev->dmap_out->bytes_in_use);
500
501 DMAbuf_reset(dev);
502 spin_lock_irqsave(&dmap->lock,flags);
503 adev->d->close(dev);
504
505 if (adev->open_mode & OPEN_WRITE)
506 close_dmap(adev, adev->dmap_out);
507
508 if (adev->open_mode == OPEN_READ ||
509 (adev->open_mode != OPEN_WRITE &&
510 (adev->flags & DMA_DUPLEX)))
511 close_dmap(adev, adev->dmap_in);
512 adev->open_mode = 0;
513 spin_unlock_irqrestore(&dmap->lock,flags);
514 return 0;
515}
516/* called with dmap->lock dold */
517int DMAbuf_activate_recording(int dev, struct dma_buffparms *dmap)
518{
519 struct audio_operations *adev = audio_devs[dev];
520 int err;
521
522 if (!(adev->open_mode & OPEN_READ))
523 return 0;
524 if (!(adev->enable_bits & PCM_ENABLE_INPUT))
525 return 0;
526 if (dmap->dma_mode == DMODE_OUTPUT) { /* Direction change */
527 /* release lock - it's not recursive */
528 spin_unlock_irq(&dmap->lock);
529 DMAbuf_sync(dev);
530 DMAbuf_reset(dev);
531 spin_lock_irq(&dmap->lock);
532 dmap->dma_mode = DMODE_NONE;
533 }
534 if (!dmap->dma_mode) {
535 reorganize_buffers(dev, dmap, 1);
536 if ((err = adev->d->prepare_for_input(dev,
537 dmap->fragment_size, dmap->nbufs)) < 0)
538 return err;
539 dmap->dma_mode = DMODE_INPUT;
540 }
541 if (!(dmap->flags & DMA_ACTIVE)) {
542 if (dmap->needs_reorg)
543 reorganize_buffers(dev, dmap, 0);
544 local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
545 adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
546 dmap->fragment_size, 0);
547 dmap->flags |= DMA_ACTIVE;
548 if (adev->d->trigger)
549 adev->d->trigger(dev, adev->enable_bits * adev->go);
550 }
551 return 0;
552}
553/* acquires lock */
554int DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
555{
556 struct audio_operations *adev = audio_devs[dev];
557 unsigned long flags;
558 int err = 0, n = 0;
559 struct dma_buffparms *dmap = adev->dmap_in;
560
561 if (!(adev->open_mode & OPEN_READ))
562 return -EIO;
563 spin_lock_irqsave(&dmap->lock,flags);
564 if (dmap->needs_reorg)
565 reorganize_buffers(dev, dmap, 0);
566 if (adev->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
567/* printk(KERN_WARNING "Sound: Can't read from mmapped device (1)\n");*/
568 spin_unlock_irqrestore(&dmap->lock,flags);
569 return -EINVAL;
570 } else while (dmap->qlen <= 0 && n++ < 10) {
571 long timeout = MAX_SCHEDULE_TIMEOUT;
572 if (!(adev->enable_bits & PCM_ENABLE_INPUT) || !adev->go) {
573 spin_unlock_irqrestore(&dmap->lock,flags);
574 return -EAGAIN;
575 }
576 if ((err = DMAbuf_activate_recording(dev, dmap)) < 0) {
577 spin_unlock_irqrestore(&dmap->lock,flags);
578 return err;
579 }
580 /* Wait for the next block */
581
582 if (dontblock) {
583 spin_unlock_irqrestore(&dmap->lock,flags);
584 return -EAGAIN;
585 }
586 if (adev->go)
587 timeout = dmabuf_timeout(dmap);
588
589 spin_unlock_irqrestore(&dmap->lock,flags);
590 timeout = oss_broken_sleep_on(&adev->in_sleeper, timeout);
591 if (!timeout) {
592 /* FIXME: include device name */
593 err = -EIO;
594 printk(KERN_WARNING "Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
595 dma_reset_input(dev);
596 } else
597 err = -EINTR;
598 spin_lock_irqsave(&dmap->lock,flags);
599 }
600 spin_unlock_irqrestore(&dmap->lock,flags);
601
602 if (dmap->qlen <= 0)
603 return err ? err : -EINTR;
604 *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
605 *len = dmap->fragment_size - dmap->counts[dmap->qhead];
606
607 return dmap->qhead;
608}
609
610int DMAbuf_rmchars(int dev, int buff_no, int c)
611{
612 struct audio_operations *adev = audio_devs[dev];
613 struct dma_buffparms *dmap = adev->dmap_in;
614 int p = dmap->counts[dmap->qhead] + c;
615
616 if (dmap->mapping_flags & DMA_MAP_MAPPED)
617 {
618/* printk("Sound: Can't read from mmapped device (2)\n");*/
619 return -EINVAL;
620 }
621 else if (dmap->qlen <= 0)
622 return -EIO;
623 else if (p >= dmap->fragment_size) { /* This buffer is completely empty */
624 dmap->counts[dmap->qhead] = 0;
625 dmap->qlen--;
626 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
627 }
628 else dmap->counts[dmap->qhead] = p;
629
630 return 0;
631}
632/* MUST be called with dmap->lock hold */
633int DMAbuf_get_buffer_pointer(int dev, struct dma_buffparms *dmap, int direction)
634{
635 /*
636 * Try to approximate the active byte position of the DMA pointer within the
637 * buffer area as well as possible.
638 */
639
640 int pos;
641 unsigned long f;
642
643 if (!(dmap->flags & DMA_ACTIVE))
644 pos = 0;
645 else {
646 int chan = dmap->dma;
647
648 f=claim_dma_lock();
649 clear_dma_ff(chan);
650
651 if(!isa_dma_bridge_buggy)
652 disable_dma(dmap->dma);
653
654 pos = get_dma_residue(chan);
655
656 pos = dmap->bytes_in_use - pos;
657
658 if (!(dmap->mapping_flags & DMA_MAP_MAPPED)) {
659 if (direction == DMODE_OUTPUT) {
660 if (dmap->qhead == 0)
661 if (pos > dmap->fragment_size)
662 pos = 0;
663 } else {
664 if (dmap->qtail == 0)
665 if (pos > dmap->fragment_size)
666 pos = 0;
667 }
668 }
669 if (pos < 0)
670 pos = 0;
671 if (pos >= dmap->bytes_in_use)
672 pos = 0;
673
674 if(!isa_dma_bridge_buggy)
675 enable_dma(dmap->dma);
676
677 release_dma_lock(f);
678 }
679 /* printk( "%04x ", pos); */
680
681 return pos;
682}
683
684/*
685 * DMAbuf_start_devices() is called by the /dev/music driver to start
686 * one or more audio devices at desired moment.
687 */
688
689void DMAbuf_start_devices(unsigned int devmask)
690{
691 struct audio_operations *adev;
692 int dev;
693
694 for (dev = 0; dev < num_audiodevs; dev++) {
695 if (!(devmask & (1 << dev)))
696 continue;
697 if (!(adev = audio_devs[dev]))
698 continue;
699 if (adev->open_mode == 0)
700 continue;
701 if (adev->go)
702 continue;
703 /* OK to start the device */
704 adev->go = 1;
705 if (adev->d->trigger)
706 adev->d->trigger(dev,adev->enable_bits * adev->go);
707 }
708}
709/* via poll called without a lock ?*/
710int DMAbuf_space_in_queue(int dev)
711{
712 struct audio_operations *adev = audio_devs[dev];
713 int len, max, tmp;
714 struct dma_buffparms *dmap = adev->dmap_out;
715 int lim = dmap->nbufs;
716
717 if (lim < 2)
718 lim = 2;
719
720 if (dmap->qlen >= lim) /* No space at all */
721 return 0;
722
723 /*
724 * Verify that there are no more pending buffers than the limit
725 * defined by the process.
726 */
727
728 max = dmap->max_fragments;
729 if (max > lim)
730 max = lim;
731 len = dmap->qlen;
732
733 if (adev->d->local_qlen) {
734 tmp = adev->d->local_qlen(dev);
735 if (tmp && len)
736 tmp--; /* This buffer has been counted twice */
737 len += tmp;
738 }
739 if (dmap->byte_counter % dmap->fragment_size) /* There is a partial fragment */
740 len = len + 1;
741
742 if (len >= max)
743 return 0;
744 return max - len;
745}
746/* MUST not hold the spinlock - this function may sleep */
747static int output_sleep(int dev, int dontblock)
748{
749 struct audio_operations *adev = audio_devs[dev];
750 int err = 0;
751 struct dma_buffparms *dmap = adev->dmap_out;
752 long timeout;
753 long timeout_value;
754
755 if (dontblock)
756 return -EAGAIN;
757 if (!(adev->enable_bits & PCM_ENABLE_OUTPUT))
758 return -EAGAIN;
759
760 /*
761 * Wait for free space
762 */
763 if (signal_pending(current))
764 return -EINTR;
765 timeout = (adev->go && !(dmap->flags & DMA_NOTIMEOUT));
766 if (timeout)
767 timeout_value = dmabuf_timeout(dmap);
768 else
769 timeout_value = MAX_SCHEDULE_TIMEOUT;
770 timeout_value = oss_broken_sleep_on(&adev->out_sleeper, timeout_value);
771 if (timeout != MAX_SCHEDULE_TIMEOUT && !timeout_value) {
772 printk(KERN_WARNING "Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
773 dma_reset_output(dev);
774 } else {
775 if (signal_pending(current))
776 err = -EINTR;
777 }
778 return err;
779}
780/* called with the lock held */
781static int find_output_space(int dev, char **buf, int *size)
782{
783 struct audio_operations *adev = audio_devs[dev];
784 struct dma_buffparms *dmap = adev->dmap_out;
785 unsigned long active_offs;
786 long len, offs;
787 int maxfrags;
788 int occupied_bytes = (dmap->user_counter % dmap->fragment_size);
789
790 *buf = dmap->raw_buf;
791 if (!(maxfrags = DMAbuf_space_in_queue(dev)) && !occupied_bytes)
792 return 0;
793
794#ifdef BE_CONSERVATIVE
795 active_offs = dmap->byte_counter + dmap->qhead * dmap->fragment_size;
796#else
797 active_offs = max(DMAbuf_get_buffer_pointer(dev, dmap, DMODE_OUTPUT), 0);
798 /* Check for pointer wrapping situation */
799 if (active_offs >= dmap->bytes_in_use)
800 active_offs = 0;
801 active_offs += dmap->byte_counter;
802#endif
803
804 offs = (dmap->user_counter % dmap->bytes_in_use) & ~SAMPLE_ROUNDUP;
805 if (offs < 0 || offs >= dmap->bytes_in_use) {
806 printk(KERN_ERR "Sound: Got unexpected offs %ld. Giving up.\n", offs);
807 printk("Counter = %ld, bytes=%d\n", dmap->user_counter, dmap->bytes_in_use);
808 return 0;
809 }
810 *buf = dmap->raw_buf + offs;
811
812 len = active_offs + dmap->bytes_in_use - dmap->user_counter; /* Number of unused bytes in buffer */
813
814 if ((offs + len) > dmap->bytes_in_use)
815 len = dmap->bytes_in_use - offs;
816 if (len < 0) {
817 return 0;
818 }
819 if (len > ((maxfrags * dmap->fragment_size) - occupied_bytes))
820 len = (maxfrags * dmap->fragment_size) - occupied_bytes;
821 *size = len & ~SAMPLE_ROUNDUP;
822 return (*size > 0);
823}
824/* acquires lock */
825int DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
826{
827 struct audio_operations *adev = audio_devs[dev];
828 unsigned long flags;
829 int err = -EIO;
830 struct dma_buffparms *dmap = adev->dmap_out;
831
832 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
833/* printk(KERN_DEBUG "Sound: Can't write to mmapped device (3)\n");*/
834 return -EINVAL;
835 }
836 spin_lock_irqsave(&dmap->lock,flags);
837 if (dmap->needs_reorg)
838 reorganize_buffers(dev, dmap, 0);
839
840 if (dmap->dma_mode == DMODE_INPUT) { /* Direction change */
841 spin_unlock_irqrestore(&dmap->lock,flags);
842 DMAbuf_reset(dev);
843 spin_lock_irqsave(&dmap->lock,flags);
844 }
845 dmap->dma_mode = DMODE_OUTPUT;
846
847 while (find_output_space(dev, buf, size) <= 0) {
848 spin_unlock_irqrestore(&dmap->lock,flags);
849 if ((err = output_sleep(dev, dontblock)) < 0) {
850 return err;
851 }
852 spin_lock_irqsave(&dmap->lock,flags);
853 }
854
855 spin_unlock_irqrestore(&dmap->lock,flags);
856 return 0;
857}
858/* has to acquire dmap->lock */
859int DMAbuf_move_wrpointer(int dev, int l)
860{
861 struct audio_operations *adev = audio_devs[dev];
862 struct dma_buffparms *dmap = adev->dmap_out;
863 unsigned long ptr;
864 unsigned long end_ptr, p;
865 int post;
866 unsigned long flags;
867
868 spin_lock_irqsave(&dmap->lock,flags);
869 post= (dmap->flags & DMA_POST);
870 ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
871
872 dmap->flags &= ~DMA_POST;
873 dmap->cfrag = -1;
874 dmap->user_counter += l;
875 dmap->flags |= DMA_DIRTY;
876
877 if (dmap->byte_counter >= dmap->max_byte_counter) {
878 /* Wrap the byte counters */
879 long decr = dmap->byte_counter;
880 dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
881 decr -= dmap->byte_counter;
882 dmap->user_counter -= decr;
883 }
884 end_ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
885
886 p = (dmap->user_counter - 1) % dmap->bytes_in_use;
887 dmap->neutral_byte = dmap->raw_buf[p];
888
889 /* Update the fragment based bookkeeping too */
890 while (ptr < end_ptr) {
891 dmap->counts[dmap->qtail] = dmap->fragment_size;
892 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
893 dmap->qlen++;
894 ptr += dmap->fragment_size;
895 }
896
897 dmap->counts[dmap->qtail] = dmap->user_counter - ptr;
898
899 /*
900 * Let the low level driver perform some postprocessing to
901 * the written data.
902 */
903 if (adev->d->postprocess_write)
904 adev->d->postprocess_write(dev);
905
906 if (!(dmap->flags & DMA_ACTIVE))
907 if (dmap->qlen > 1 || (dmap->qlen > 0 && (post || dmap->qlen >= dmap->nbufs - 1)))
908 DMAbuf_launch_output(dev, dmap);
909
910 spin_unlock_irqrestore(&dmap->lock,flags);
911 return 0;
912}
913
914int DMAbuf_start_dma(int dev, unsigned long physaddr, int count, int dma_mode)
915{
916 struct audio_operations *adev = audio_devs[dev];
917 struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
918
919 if (dmap->raw_buf == NULL) {
920 printk(KERN_ERR "sound: DMA buffer(1) == NULL\n");
921 printk("Device %d, chn=%s\n", dev, (dmap == adev->dmap_out) ? "out" : "in");
922 return 0;
923 }
924 if (dmap->dma < 0)
925 return 0;
926 sound_start_dma(dmap, physaddr, count, dma_mode);
927 return count;
928}
929EXPORT_SYMBOL(DMAbuf_start_dma);
930
931static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode)
932{
933 struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
934
935 if (dmap->raw_buf == NULL) {
936 printk(KERN_ERR "sound: DMA buffer(2) == NULL\n");
937 printk(KERN_ERR "Device %s, chn=%s\n", adev->name, (dmap == adev->dmap_out) ? "out" : "in");
938 return 0;
939 }
940 if (dmap->flags & DMA_NODMA)
941 return 1;
942 if (dmap->dma < 0)
943 return 0;
944 sound_start_dma(dmap, dmap->raw_buf_phys, dmap->bytes_in_use, dma_mode | DMA_AUTOINIT);
945 dmap->flags |= DMA_STARTED;
946 return count;
947}
948
949static void finish_output_interrupt(int dev, struct dma_buffparms *dmap)
950{
951 struct audio_operations *adev = audio_devs[dev];
952
953 if (dmap->audio_callback != NULL)
954 dmap->audio_callback(dev, dmap->callback_parm);
955 wake_up(&adev->out_sleeper);
956 wake_up(&adev->poll_sleeper);
957}
958/* called with dmap->lock held in irq context*/
959static void do_outputintr(int dev, int dummy)
960{
961 struct audio_operations *adev = audio_devs[dev];
962 struct dma_buffparms *dmap = adev->dmap_out;
963 int this_fragment;
964
965 if (dmap->raw_buf == NULL) {
966 printk(KERN_ERR "Sound: Error. Audio interrupt (%d) after freeing buffers.\n", dev);
967 return;
968 }
969 if (dmap->mapping_flags & DMA_MAP_MAPPED) { /* Virtual memory mapped access */
970 /* mmapped access */
971 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
972 if (dmap->qhead == 0) { /* Wrapped */
973 dmap->byte_counter += dmap->bytes_in_use;
974 if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
975 long decr = dmap->byte_counter;
976 dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
977 decr -= dmap->byte_counter;
978 dmap->user_counter -= decr;
979 }
980 }
981 dmap->qlen++; /* Yes increment it (don't decrement) */
982 if (!(adev->flags & DMA_AUTOMODE))
983 dmap->flags &= ~DMA_ACTIVE;
984 dmap->counts[dmap->qhead] = dmap->fragment_size;
985 DMAbuf_launch_output(dev, dmap);
986 finish_output_interrupt(dev, dmap);
987 return;
988 }
989
990 dmap->qlen--;
991 this_fragment = dmap->qhead;
992 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
993
994 if (dmap->qhead == 0) { /* Wrapped */
995 dmap->byte_counter += dmap->bytes_in_use;
996 if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
997 long decr = dmap->byte_counter;
998 dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
999 decr -= dmap->byte_counter;
1000 dmap->user_counter -= decr;
1001 }
1002 }
1003 if (!(adev->flags & DMA_AUTOMODE))
1004 dmap->flags &= ~DMA_ACTIVE;
1005
1006 /*
1007 * This is dmap->qlen <= 0 except when closing when
1008 * dmap->qlen < 0
1009 */
1010
1011 while (dmap->qlen <= -dmap->closing) {
1012 dmap->underrun_count++;
1013 dmap->qlen++;
1014 if ((dmap->flags & DMA_DIRTY) && dmap->applic_profile != APF_CPUINTENS) {
1015 dmap->flags &= ~DMA_DIRTY;
1016 memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
1017 adev->dmap_out->buffsize);
1018 }
1019 dmap->user_counter += dmap->fragment_size;
1020 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1021 }
1022 if (dmap->qlen > 0)
1023 DMAbuf_launch_output(dev, dmap);
1024 finish_output_interrupt(dev, dmap);
1025}
1026/* called in irq context */
1027void DMAbuf_outputintr(int dev, int notify_only)
1028{
1029 struct audio_operations *adev = audio_devs[dev];
1030 unsigned long flags;
1031 struct dma_buffparms *dmap = adev->dmap_out;
1032
1033 spin_lock_irqsave(&dmap->lock,flags);
1034 if (!(dmap->flags & DMA_NODMA)) {
1035 int chan = dmap->dma, pos, n;
1036 unsigned long f;
1037
1038 f=claim_dma_lock();
1039
1040 if(!isa_dma_bridge_buggy)
1041 disable_dma(dmap->dma);
1042 clear_dma_ff(chan);
1043 pos = dmap->bytes_in_use - get_dma_residue(chan);
1044 if(!isa_dma_bridge_buggy)
1045 enable_dma(dmap->dma);
1046 release_dma_lock(f);
1047
1048 pos = pos / dmap->fragment_size; /* Actual qhead */
1049 if (pos < 0 || pos >= dmap->nbufs)
1050 pos = 0;
1051 n = 0;
1052 while (dmap->qhead != pos && n++ < dmap->nbufs)
1053 do_outputintr(dev, notify_only);
1054 }
1055 else
1056 do_outputintr(dev, notify_only);
1057 spin_unlock_irqrestore(&dmap->lock,flags);
1058}
1059EXPORT_SYMBOL(DMAbuf_outputintr);
1060
1061/* called with dmap->lock held in irq context */
1062static void do_inputintr(int dev)
1063{
1064 struct audio_operations *adev = audio_devs[dev];
1065 struct dma_buffparms *dmap = adev->dmap_in;
1066
1067 if (dmap->raw_buf == NULL) {
1068 printk(KERN_ERR "Sound: Fatal error. Audio interrupt after freeing buffers.\n");
1069 return;
1070 }
1071 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1072 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1073 if (dmap->qtail == 0) { /* Wrapped */
1074 dmap->byte_counter += dmap->bytes_in_use;
1075 if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
1076 long decr = dmap->byte_counter;
1077 dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
1078 decr -= dmap->byte_counter;
1079 dmap->user_counter -= decr;
1080 }
1081 }
1082 dmap->qlen++;
1083
1084 if (!(adev->flags & DMA_AUTOMODE)) {
1085 if (dmap->needs_reorg)
1086 reorganize_buffers(dev, dmap, 0);
1087 local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_READ);
1088 adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
1089 dmap->fragment_size, 1);
1090 if (adev->d->trigger)
1091 adev->d->trigger(dev, adev->enable_bits * adev->go);
1092 }
1093 dmap->flags |= DMA_ACTIVE;
1094 } else if (dmap->qlen >= (dmap->nbufs - 1)) {
1095 printk(KERN_WARNING "Sound: Recording overrun\n");
1096 dmap->underrun_count++;
1097
1098 /* Just throw away the oldest fragment but keep the engine running */
1099 dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1100 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1101 } else if (dmap->qlen >= 0 && dmap->qlen < dmap->nbufs) {
1102 dmap->qlen++;
1103 dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1104 if (dmap->qtail == 0) { /* Wrapped */
1105 dmap->byte_counter += dmap->bytes_in_use;
1106 if (dmap->byte_counter >= dmap->max_byte_counter) { /* Overflow */
1107 long decr = dmap->byte_counter;
1108 dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
1109 decr -= dmap->byte_counter;
1110 dmap->user_counter -= decr;
1111 }
1112 }
1113 }
1114 if (!(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
1115 local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
1116 adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size, dmap->fragment_size, 1);
1117 if (adev->d->trigger)
1118 adev->d->trigger(dev,adev->enable_bits * adev->go);
1119 }
1120 dmap->flags |= DMA_ACTIVE;
1121 if (dmap->qlen > 0)
1122 {
1123 wake_up(&adev->in_sleeper);
1124 wake_up(&adev->poll_sleeper);
1125 }
1126}
1127/* called in irq context */
1128void DMAbuf_inputintr(int dev)
1129{
1130 struct audio_operations *adev = audio_devs[dev];
1131 struct dma_buffparms *dmap = adev->dmap_in;
1132 unsigned long flags;
1133
1134 spin_lock_irqsave(&dmap->lock,flags);
1135
1136 if (!(dmap->flags & DMA_NODMA)) {
1137 int chan = dmap->dma, pos, n;
1138 unsigned long f;
1139
1140 f=claim_dma_lock();
1141 if(!isa_dma_bridge_buggy)
1142 disable_dma(dmap->dma);
1143 clear_dma_ff(chan);
1144 pos = dmap->bytes_in_use - get_dma_residue(chan);
1145 if(!isa_dma_bridge_buggy)
1146 enable_dma(dmap->dma);
1147 release_dma_lock(f);
1148
1149 pos = pos / dmap->fragment_size; /* Actual qhead */
1150 if (pos < 0 || pos >= dmap->nbufs)
1151 pos = 0;
1152
1153 n = 0;
1154 while (dmap->qtail != pos && ++n < dmap->nbufs)
1155 do_inputintr(dev);
1156 } else
1157 do_inputintr(dev);
1158 spin_unlock_irqrestore(&dmap->lock,flags);
1159}
1160EXPORT_SYMBOL(DMAbuf_inputintr);
1161
1162void DMAbuf_init(int dev, int dma1, int dma2)
1163{
1164 struct audio_operations *adev = audio_devs[dev];
1165 /*
1166 * NOTE! This routine could be called several times.
1167 */
1168
1169 if (adev && adev->dmap_out == NULL) {
1170 if (adev->d == NULL)
1171 panic("OSS: audio_devs[%d]->d == NULL\n", dev);
1172
1173 if (adev->parent_dev) { /* Use DMA map of the parent dev */
1174 int parent = adev->parent_dev - 1;
1175 adev->dmap_out = audio_devs[parent]->dmap_out;
1176 adev->dmap_in = audio_devs[parent]->dmap_in;
1177 } else {
1178 adev->dmap_out = adev->dmap_in = &adev->dmaps[0];
1179 adev->dmap_out->dma = dma1;
1180 if (adev->flags & DMA_DUPLEX) {
1181 adev->dmap_in = &adev->dmaps[1];
1182 adev->dmap_in->dma = dma2;
1183 }
1184 }
1185 /* Persistent DMA buffers allocated here */
1186 if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
1187 if (adev->dmap_in->raw_buf == NULL)
1188 sound_alloc_dmap(adev->dmap_in);
1189 if (adev->dmap_out->raw_buf == NULL)
1190 sound_alloc_dmap(adev->dmap_out);
1191 }
1192 }
1193}
1194
1195/* No kernel lock - DMAbuf_activate_recording protected by global cli/sti */
1196static unsigned int poll_input(struct file * file, int dev, poll_table *wait)
1197{
1198 struct audio_operations *adev = audio_devs[dev];
1199 struct dma_buffparms *dmap = adev->dmap_in;
1200
1201 if (!(adev->open_mode & OPEN_READ))
1202 return 0;
1203 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1204 if (dmap->qlen)
1205 return POLLIN | POLLRDNORM;
1206 return 0;
1207 }
1208 if (dmap->dma_mode != DMODE_INPUT) {
1209 if (dmap->dma_mode == DMODE_NONE &&
1210 adev->enable_bits & PCM_ENABLE_INPUT &&
1211 !dmap->qlen && adev->go) {
1212 unsigned long flags;
1213
1214 spin_lock_irqsave(&dmap->lock,flags);
1215 DMAbuf_activate_recording(dev, dmap);
1216 spin_unlock_irqrestore(&dmap->lock,flags);
1217 }
1218 return 0;
1219 }
1220 if (!dmap->qlen)
1221 return 0;
1222 return POLLIN | POLLRDNORM;
1223}
1224
1225static unsigned int poll_output(struct file * file, int dev, poll_table *wait)
1226{
1227 struct audio_operations *adev = audio_devs[dev];
1228 struct dma_buffparms *dmap = adev->dmap_out;
1229
1230 if (!(adev->open_mode & OPEN_WRITE))
1231 return 0;
1232 if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1233 if (dmap->qlen)
1234 return POLLOUT | POLLWRNORM;
1235 return 0;
1236 }
1237 if (dmap->dma_mode == DMODE_INPUT)
1238 return 0;
1239 if (dmap->dma_mode == DMODE_NONE)
1240 return POLLOUT | POLLWRNORM;
1241 if (!DMAbuf_space_in_queue(dev))
1242 return 0;
1243 return POLLOUT | POLLWRNORM;
1244}
1245
1246unsigned int DMAbuf_poll(struct file * file, int dev, poll_table *wait)
1247{
1248 struct audio_operations *adev = audio_devs[dev];
1249 poll_wait(file, &adev->poll_sleeper, wait);
1250 return poll_input(file, dev, wait) | poll_output(file, dev, wait);
1251}
1252
1253void DMAbuf_deinit(int dev)
1254{
1255 struct audio_operations *adev = audio_devs[dev];
1256 /* This routine is called when driver is being unloaded */
1257 if (!adev)
1258 return;
1259
1260 /* Persistent DMA buffers deallocated here */
1261 if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
1262 sound_free_dmap(adev->dmap_out);
1263 if (adev->flags & DMA_DUPLEX)
1264 sound_free_dmap(adev->dmap_in);
1265 }
1266}