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