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