1 /*
2 * sound/audio.c
3 *
4 * Device file manager for /dev/audio
5 */
6
7 /*
8 * Copyright (C) by Hannu Savolainen 1993-1997
9 *
10 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
11 * Version 2 (June 1991). See the "COPYING" file distributed with this software
12 * for more info.
13 */
14 /*
15 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
16 * Thomas Sailer : moved several static variables into struct audio_operations
17 * (which is grossly misnamed btw.) because they have the same
18 * lifetime as the rest in there and dynamic allocation saves
19 * 12k or so
20 * Thomas Sailer : use more logical O_NONBLOCK semantics
21 * Daniel Rodriksson: reworked the use of the device specific copy_user
22 * still generic
23 * Horst von Brand: Add missing #include <linux/string.h>
24 */
25
26 #include <linux/stddef.h>
27 #include <linux/string.h>
28 #include <linux/kmod.h>
29
30 #include "sound_config.h"
31 #include "ulaw.h"
32 #include "coproc.h"
33
34 #define NEUTRAL8 0x80
35 #define NEUTRAL16 0x00
36
37
38 int dma_ioctl(int dev, unsigned int cmd, caddr_t arg);
39
40 static int set_format(int dev, int fmt)
41 {
42 if (fmt != AFMT_QUERY)
43 {
44 audio_devs[dev]->local_conversion = 0;
45
46 if (!(audio_devs[dev]->format_mask & fmt)) /* Not supported */
47 {
48 if (fmt == AFMT_MU_LAW)
49 {
50 fmt = AFMT_U8;
51 audio_devs[dev]->local_conversion = CNV_MU_LAW;
52 }
53 else
54 fmt = AFMT_U8; /* This is always supported */
55 }
56 audio_devs[dev]->audio_format = audio_devs[dev]->d->set_bits(dev, fmt);
57 audio_devs[dev]->local_format = fmt;
58 }
59 else
60 return audio_devs[dev]->local_format;
61
62 if (audio_devs[dev]->local_conversion)
63 return audio_devs[dev]->local_conversion;
64 else
65 return audio_devs[dev]->local_format;
66 }
67
68 int audio_open(int dev, struct file *file)
69 {
70 int ret;
71 int bits;
72 int dev_type = dev & 0x0f;
73 int mode = translate_mode(file);
74
75 dev = dev >> 4;
76
77 if (dev_type == SND_DEV_DSP16)
78 bits = 16;
79 else
80 bits = 8;
81
82 if (dev < 0 || dev >= num_audiodevs)
83 return -ENXIO;
84
85 if (audio_devs[dev]->d->owner)
86 __MOD_INC_USE_COUNT (audio_devs[dev]->d->owner);
87
88 if ((ret = DMAbuf_open(dev, mode)) < 0)
89 return ret;
90
91 if (audio_devs[dev]->coproc) {
92 if ((ret = audio_devs[dev]->coproc->
93 open(audio_devs[dev]->coproc->devc, COPR_PCM)) < 0) {
94 audio_release(dev, file);
95 printk(KERN_WARNING "Sound: Can't access coprocessor device\n");
96 return ret;
97 }
98 }
99
100 audio_devs[dev]->local_conversion = 0;
101
102 if (dev_type == SND_DEV_AUDIO)
103 set_format(dev, AFMT_MU_LAW);
104 else
105 set_format(dev, bits);
106
107 audio_devs[dev]->audio_mode = AM_NONE;
108
109
110 return ret;
111 }
112
113 static void sync_output(int dev)
114 {
115 int p, i;
116 int l;
117 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
118
119 if (dmap->fragment_size <= 0)
120 return;
121 dmap->flags |= DMA_POST;
122
123 /* Align the write pointer with fragment boundaries */
124
125 if ((l = dmap->user_counter % dmap->fragment_size) > 0)
126 {
127 int len;
128 unsigned long offs = dmap->user_counter % dmap->bytes_in_use;
129
130 len = dmap->fragment_size - l;
131 memset(dmap->raw_buf + offs, dmap->neutral_byte, len);
132 DMAbuf_move_wrpointer(dev, len);
133 }
134
135 /*
136 * Clean all unused buffer fragments.
137 */
138
139 p = dmap->qtail;
140 dmap->flags |= DMA_POST;
141
142 for (i = dmap->qlen + 1; i < dmap->nbufs; i++)
143 {
144 p = (p + 1) % dmap->nbufs;
145 if (((dmap->raw_buf + p * dmap->fragment_size) + dmap->fragment_size) >
146 (dmap->raw_buf + dmap->buffsize))
147 printk(KERN_ERR "audio: Buffer error 2\n");
148
149 memset(dmap->raw_buf + p * dmap->fragment_size,
150 dmap->neutral_byte,
151 dmap->fragment_size);
152 }
153
154 dmap->flags |= DMA_DIRTY;
155 }
156
157 void audio_release(int dev, struct file *file)
158 {
159 int mode = translate_mode(file);
160
161 dev = dev >> 4;
162
163 /*
164 * We do this in DMAbuf_release(). Why are we doing it
165 * here? Why don't we test the file mode before setting
166 * both flags? DMAbuf_release() does.
167 * ...pester...pester...pester...
168 */
169 audio_devs[dev]->dmap_out->closing = 1;
170 audio_devs[dev]->dmap_in->closing = 1;
171
172 /*
173 * We need to make sure we allocated the dmap_out buffer
174 * before we go mucking around with it in sync_output().
175 */
176 if (mode & OPEN_WRITE)
177 sync_output(dev);
178
179 if (audio_devs[dev]->coproc)
180 audio_devs[dev]->coproc->close(audio_devs[dev]->coproc->devc, COPR_PCM);
181 DMAbuf_release(dev, mode);
182
183 if (audio_devs[dev]->d->owner)
184 __MOD_DEC_USE_COUNT (audio_devs[dev]->d->owner);
185 }
186
187 static void translate_bytes(const unsigned char *table, unsigned char *buff, int n)
188 {
189 unsigned long i;
190
191 if (n <= 0)
192 return;
193
194 for (i = 0; i < n; ++i)
195 buff[i] = table[buff[i]];
196 }
197
198 int audio_write(int dev, struct file *file, const char *buf, int count)
199 {
200 int c, p, l, buf_size, used, returned;
201 int err;
202 char *dma_buf;
203
204 dev = dev >> 4;
205
206 p = 0;
207 c = count;
208
209 if(count < 0)
210 return -EINVAL;
211
212 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
213 return -EPERM;
214
215 if (audio_devs[dev]->flags & DMA_DUPLEX)
216 audio_devs[dev]->audio_mode |= AM_WRITE;
217 else
218 audio_devs[dev]->audio_mode = AM_WRITE;
219
220 if (!count) /* Flush output */
221 {
222 sync_output(dev);
223 return 0;
224 }
225
226 while (c)
227 {
228 if ((err = DMAbuf_getwrbuffer(dev, &dma_buf, &buf_size, !!(file->f_flags & O_NONBLOCK))) < 0)
229 {
230 /* Handle nonblocking mode */
231 if ((file->f_flags & O_NONBLOCK) && err == -EAGAIN)
232 return p? p : -EAGAIN; /* No more space. Return # of accepted bytes */
233 return err;
234 }
235 l = c;
236
237 if (l > buf_size)
238 l = buf_size;
239
240 returned = l;
241 used = l;
242 if (!audio_devs[dev]->d->copy_user)
243 {
244 if ((dma_buf + l) >
245 (audio_devs[dev]->dmap_out->raw_buf + audio_devs[dev]->dmap_out->buffsize))
246 {
247 printk(KERN_ERR "audio: Buffer error 3 (%lx,%d), (%lx, %d)\n", (long) dma_buf, l, (long) audio_devs[dev]->dmap_out->raw_buf, (int) audio_devs[dev]->dmap_out->buffsize);
248 return -EDOM;
249 }
250 if (dma_buf < audio_devs[dev]->dmap_out->raw_buf)
251 {
252 printk(KERN_ERR "audio: Buffer error 13 (%lx<%lx)\n", (long) dma_buf, (long) audio_devs[dev]->dmap_out->raw_buf);
253 return -EDOM;
254 }
255 if(copy_from_user(dma_buf, &(buf)[p], l))
256 return -EFAULT;
257 }
258 else audio_devs[dev]->d->copy_user (dev,
259 dma_buf, 0,
260 buf, p,
261 c, buf_size,
262 &used, &returned,
263 l);
264 l = returned;
265
266 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
267 {
268 /*
269 * This just allows interrupts while the conversion is running
270 */
271 sti();
272 translate_bytes(ulaw_dsp, (unsigned char *) dma_buf, l);
273 }
274 c -= used;
275 p += used;
276 DMAbuf_move_wrpointer(dev, l);
277
278 }
279
280 return count;
281 }
282
283 int audio_read(int dev, struct file *file, char *buf, int count)
284 {
285 int c, p, l;
286 char *dmabuf;
287 int buf_no;
288
289 dev = dev >> 4;
290 p = 0;
291 c = count;
292
293 if (!(audio_devs[dev]->open_mode & OPEN_READ))
294 return -EPERM;
295
296 if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
297 sync_output(dev);
298
299 if (audio_devs[dev]->flags & DMA_DUPLEX)
300 audio_devs[dev]->audio_mode |= AM_READ;
301 else
302 audio_devs[dev]->audio_mode = AM_READ;
303
304 while(c)
305 {
306 if ((buf_no = DMAbuf_getrdbuffer(dev, &dmabuf, &l, !!(file->f_flags & O_NONBLOCK))) < 0)
307 {
308 /*
309 * Nonblocking mode handling. Return current # of bytes
310 */
311
312 if (p > 0) /* Avoid throwing away data */
313 return p; /* Return it instead */
314
315 if ((file->f_flags & O_NONBLOCK) && buf_no == -EAGAIN)
316 return -EAGAIN;
317
318 return buf_no;
319 }
320 if (l > c)
321 l = c;
322
323 /*
324 * Insert any local processing here.
325 */
326
327 if (audio_devs[dev]->local_conversion & CNV_MU_LAW)
328 {
329 /*
330 * This just allows interrupts while the conversion is running
331 */
332 sti();
333
334 translate_bytes(dsp_ulaw, (unsigned char *) dmabuf, l);
335 }
336
337 {
338 char *fixit = dmabuf;
339
340 if(copy_to_user(&(buf)[p], fixit, l))
341 return -EFAULT;
342 };
343
344 DMAbuf_rmchars(dev, buf_no, l);
345
346 p += l;
347 c -= l;
348 }
349
350 return count - c;
351 }
352
353 int audio_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
354 {
355 int val, count;
356 unsigned long flags;
357 struct dma_buffparms *dmap;
358
359 dev = dev >> 4;
360
361 if (_IOC_TYPE(cmd) == 'C') {
362 if (audio_devs[dev]->coproc) /* Coprocessor ioctl */
363 return audio_devs[dev]->coproc->ioctl(audio_devs[dev]->coproc->devc, cmd, arg, 0);
364 /* else
365 printk(KERN_DEBUG"/dev/dsp%d: No coprocessor for this device\n", dev); */
366 return -ENXIO;
367 }
368 else switch (cmd)
369 {
370 case SNDCTL_DSP_SYNC:
371 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
372 return 0;
373 if (audio_devs[dev]->dmap_out->fragment_size == 0)
374 return 0;
375 sync_output(dev);
376 DMAbuf_sync(dev);
377 DMAbuf_reset(dev);
378 return 0;
379
380 case SNDCTL_DSP_POST:
381 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
382 return 0;
383 if (audio_devs[dev]->dmap_out->fragment_size == 0)
384 return 0;
385 audio_devs[dev]->dmap_out->flags |= DMA_POST | DMA_DIRTY;
386 sync_output(dev);
387 dma_ioctl(dev, SNDCTL_DSP_POST, (caddr_t) 0);
388 return 0;
389
390 case SNDCTL_DSP_RESET:
391 audio_devs[dev]->audio_mode = AM_NONE;
392 DMAbuf_reset(dev);
393 return 0;
394
395 case SNDCTL_DSP_GETFMTS:
396 val = audio_devs[dev]->format_mask | AFMT_MU_LAW;
397 break;
398
399 case SNDCTL_DSP_SETFMT:
400 if (get_user(val, (int *)arg))
401 return -EFAULT;
402 val = set_format(dev, val);
403 break;
404
405 case SNDCTL_DSP_GETISPACE:
406 if (!(audio_devs[dev]->open_mode & OPEN_READ))
407 return 0;
408 if ((audio_devs[dev]->audio_mode & AM_WRITE) && !(audio_devs[dev]->flags & DMA_DUPLEX))
409 return -EBUSY;
410 return dma_ioctl(dev, cmd, arg);
411
412 case SNDCTL_DSP_GETOSPACE:
413 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
414 return -EPERM;
415 if ((audio_devs[dev]->audio_mode & AM_READ) && !(audio_devs[dev]->flags & DMA_DUPLEX))
416 return -EBUSY;
417 return dma_ioctl(dev, cmd, arg);
418
419 case SNDCTL_DSP_NONBLOCK:
420 file->f_flags |= O_NONBLOCK;
421 return 0;
422
423 case SNDCTL_DSP_GETCAPS:
424 val = 1 | DSP_CAP_MMAP; /* Revision level of this ioctl() */
425 if (audio_devs[dev]->flags & DMA_DUPLEX &&
426 audio_devs[dev]->open_mode == OPEN_READWRITE)
427 val |= DSP_CAP_DUPLEX;
428 if (audio_devs[dev]->coproc)
429 val |= DSP_CAP_COPROC;
430 if (audio_devs[dev]->d->local_qlen) /* Device has hidden buffers */
431 val |= DSP_CAP_BATCH;
432 if (audio_devs[dev]->d->trigger) /* Supports SETTRIGGER */
433 val |= DSP_CAP_TRIGGER;
434 break;
435
436 case SOUND_PCM_WRITE_RATE:
437 if (get_user(val, (int *)arg))
438 return -EFAULT;
439 val = audio_devs[dev]->d->set_speed(dev, val);
440 break;
441
442 case SOUND_PCM_READ_RATE:
443 val = audio_devs[dev]->d->set_speed(dev, 0);
444 break;
445
446 case SNDCTL_DSP_STEREO:
447 if (get_user(val, (int *)arg))
448 return -EFAULT;
449 if (val > 1 || val < 0)
450 return -EINVAL;
451 val = audio_devs[dev]->d->set_channels(dev, val + 1) - 1;
452 break;
453
454 case SOUND_PCM_WRITE_CHANNELS:
455 if (get_user(val, (int *)arg))
456 return -EFAULT;
457 val = audio_devs[dev]->d->set_channels(dev, val);
458 break;
459
460 case SOUND_PCM_READ_CHANNELS:
461 val = audio_devs[dev]->d->set_channels(dev, 0);
462 break;
463
464 case SOUND_PCM_READ_BITS:
465 val = audio_devs[dev]->d->set_bits(dev, 0);
466 break;
467
468 case SNDCTL_DSP_SETDUPLEX:
469 if (audio_devs[dev]->open_mode != OPEN_READWRITE)
470 return -EPERM;
471 return (audio_devs[dev]->flags & DMA_DUPLEX) ? 0 : -EIO;
472
473 case SNDCTL_DSP_PROFILE:
474 if (get_user(val, (int *)arg))
475 return -EFAULT;
476 if (audio_devs[dev]->open_mode & OPEN_WRITE)
477 audio_devs[dev]->dmap_out->applic_profile = val;
478 if (audio_devs[dev]->open_mode & OPEN_READ)
479 audio_devs[dev]->dmap_in->applic_profile = val;
480 return 0;
481
482 case SNDCTL_DSP_GETODELAY:
483 dmap = audio_devs[dev]->dmap_out;
484 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
485 return -EINVAL;
486 if (!(dmap->flags & DMA_ALLOC_DONE))
487 {
488 val=0;
489 break;
490 }
491
492 save_flags (flags);
493 cli();
494 /* Compute number of bytes that have been played */
495 count = DMAbuf_get_buffer_pointer (dev, dmap, DMODE_OUTPUT);
496 if (count < dmap->fragment_size && dmap->qhead != 0)
497 count += dmap->bytes_in_use; /* Pointer wrap not handled yet */
498 count += dmap->byte_counter;
499
500 /* Substract current count from the number of bytes written by app */
501 count = dmap->user_counter - count;
502 if (count < 0)
503 count = 0;
504 restore_flags (flags);
505 val = count;
506 break;
507
508 default:
509 return dma_ioctl(dev, cmd, arg);
510 }
511 return put_user(val, (int *)arg);
512 }
513
514 void audio_init_devices(void)
515 {
516 /*
517 * NOTE! This routine could be called several times during boot.
518 */
519 }
520
521 void reorganize_buffers(int dev, struct dma_buffparms *dmap, int recording)
522 {
523 /*
524 * This routine breaks the physical device buffers to logical ones.
525 */
526
527 struct audio_operations *dsp_dev = audio_devs[dev];
528
529 unsigned i, n;
530 unsigned sr, nc, sz, bsz;
531
532 sr = dsp_dev->d->set_speed(dev, 0);
533 nc = dsp_dev->d->set_channels(dev, 0);
534 sz = dsp_dev->d->set_bits(dev, 0);
535
536 if (sz == 8)
537 dmap->neutral_byte = NEUTRAL8;
538 else
539 dmap->neutral_byte = NEUTRAL16;
540
541 if (sr < 1 || nc < 1 || sz < 1)
542 {
543 /* printk(KERN_DEBUG "Warning: Invalid PCM parameters[%d] sr=%d, nc=%d, sz=%d\n", dev, sr, nc, sz);*/
544 sr = DSP_DEFAULT_SPEED;
545 nc = 1;
546 sz = 8;
547 }
548
549 sz = sr * nc * sz;
550
551 sz /= 8; /* #bits -> #bytes */
552 dmap->data_rate = sz;
553
554 if (!dmap->needs_reorg)
555 return;
556 dmap->needs_reorg = 0;
557
558 if (dmap->fragment_size == 0)
559 {
560 /* Compute the fragment size using the default algorithm */
561
562 /*
563 * Compute a buffer size for time not exceeding 1 second.
564 * Usually this algorithm gives a buffer size for 0.5 to 1.0 seconds
565 * of sound (using the current speed, sample size and #channels).
566 */
567
568 bsz = dmap->buffsize;
569 while (bsz > sz)
570 bsz /= 2;
571
572 if (bsz == dmap->buffsize)
573 bsz /= 2; /* Needs at least 2 buffers */
574
575 /*
576 * Split the computed fragment to smaller parts. After 3.5a9
577 * the default subdivision is 4 which should give better
578 * results when recording.
579 */
580
581 if (dmap->subdivision == 0) /* Not already set */
582 {
583 dmap->subdivision = 4; /* Init to the default value */
584
585 if ((bsz / dmap->subdivision) > 4096)
586 dmap->subdivision *= 2;
587 if ((bsz / dmap->subdivision) < 4096)
588 dmap->subdivision = 1;
589 }
590 bsz /= dmap->subdivision;
591
592 if (bsz < 16)
593 bsz = 16; /* Just a sanity check */
594
595 dmap->fragment_size = bsz;
596 }
597 else
598 {
599 /*
600 * The process has specified the buffer size with SNDCTL_DSP_SETFRAGMENT or
601 * the buffer size computation has already been done.
602 */
603 if (dmap->fragment_size > (dmap->buffsize / 2))
604 dmap->fragment_size = (dmap->buffsize / 2);
605 bsz = dmap->fragment_size;
606 }
607
608 if (audio_devs[dev]->min_fragment)
609 if (bsz < (1 << audio_devs[dev]->min_fragment))
610 bsz = 1 << audio_devs[dev]->min_fragment;
611 if (audio_devs[dev]->max_fragment)
612 if (bsz > (1 << audio_devs[dev]->max_fragment))
613 bsz = 1 << audio_devs[dev]->max_fragment;
614 bsz &= ~0x07; /* Force size which is multiple of 8 bytes */
615 #ifdef OS_DMA_ALIGN_CHECK
616 OS_DMA_ALIGN_CHECK(bsz);
617 #endif
618
619 n = dmap->buffsize / bsz;
620 if (n > MAX_SUB_BUFFERS)
621 n = MAX_SUB_BUFFERS;
622 if (n > dmap->max_fragments)
623 n = dmap->max_fragments;
624
625 if (n < 2)
626 {
627 n = 2;
628 bsz /= 2;
629 }
630 dmap->nbufs = n;
631 dmap->bytes_in_use = n * bsz;
632 dmap->fragment_size = bsz;
633 dmap->max_byte_counter = (dmap->data_rate * 60 * 60) +
634 dmap->bytes_in_use; /* Approximately one hour */
635
636 if (dmap->raw_buf)
637 {
638 memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use);
639 }
640
641 for (i = 0; i < dmap->nbufs; i++)
642 {
643 dmap->counts[i] = 0;
644 }
645
646 dmap->flags |= DMA_ALLOC_DONE | DMA_EMPTY;
647 }
648
649 static int dma_subdivide(int dev, struct dma_buffparms *dmap, int fact)
650 {
651 if (fact == 0)
652 {
653 fact = dmap->subdivision;
654 if (fact == 0)
655 fact = 1;
656 return fact;
657 }
658 if (dmap->subdivision != 0 || dmap->fragment_size) /* Too late to change */
659 return -EINVAL;
660
661 if (fact > MAX_REALTIME_FACTOR)
662 return -EINVAL;
663
664 if (fact != 1 && fact != 2 && fact != 4 && fact != 8 && fact != 16)
665 return -EINVAL;
666
667 dmap->subdivision = fact;
668 return fact;
669 }
670
671 static int dma_set_fragment(int dev, struct dma_buffparms *dmap, int fact)
672 {
673 int bytes, count;
674
675 if (fact == 0)
676 return -EIO;
677
678 if (dmap->subdivision != 0 ||
679 dmap->fragment_size) /* Too late to change */
680 return -EINVAL;
681
682 bytes = fact & 0xffff;
683 count = (fact >> 16) & 0x7fff;
684
685 if (count == 0)
686 count = MAX_SUB_BUFFERS;
687 else if (count < MAX_SUB_BUFFERS)
688 count++;
689
690 if (bytes < 4 || bytes > 17) /* <16 || > 512k */
691 return -EINVAL;
692
693 if (count < 2)
694 return -EINVAL;
695
696 if (audio_devs[dev]->min_fragment > 0)
697 if (bytes < audio_devs[dev]->min_fragment)
698 bytes = audio_devs[dev]->min_fragment;
699
700 if (audio_devs[dev]->max_fragment > 0)
701 if (bytes > audio_devs[dev]->max_fragment)
702 bytes = audio_devs[dev]->max_fragment;
703
704 #ifdef OS_DMA_MINBITS
705 if (bytes < OS_DMA_MINBITS)
706 bytes = OS_DMA_MINBITS;
707 #endif
708
709 dmap->fragment_size = (1 << bytes);
710 dmap->max_fragments = count;
711
712 if (dmap->fragment_size > dmap->buffsize)
713 dmap->fragment_size = dmap->buffsize;
714
715 if (dmap->fragment_size == dmap->buffsize &&
716 audio_devs[dev]->flags & DMA_AUTOMODE)
717 dmap->fragment_size /= 2; /* Needs at least 2 buffers */
718
719 dmap->subdivision = 1; /* Disable SNDCTL_DSP_SUBDIVIDE */
720 return bytes | ((count - 1) << 16);
721 }
722
723 int dma_ioctl(int dev, unsigned int cmd, caddr_t arg)
724 {
725 struct dma_buffparms *dmap_out = audio_devs[dev]->dmap_out;
726 struct dma_buffparms *dmap_in = audio_devs[dev]->dmap_in;
727 struct dma_buffparms *dmap;
728 audio_buf_info info;
729 count_info cinfo;
730 int fact, ret, changed, bits, count, err;
731 unsigned long flags;
732
733 switch (cmd)
734 {
735 case SNDCTL_DSP_SUBDIVIDE:
736 ret = 0;
737 if (get_user(fact, (int *)arg))
738 return -EFAULT;
739 if (audio_devs[dev]->open_mode & OPEN_WRITE)
740 ret = dma_subdivide(dev, dmap_out, fact);
741 if (ret < 0)
742 return ret;
743 if (audio_devs[dev]->open_mode != OPEN_WRITE ||
744 (audio_devs[dev]->flags & DMA_DUPLEX &&
745 audio_devs[dev]->open_mode & OPEN_READ))
746 ret = dma_subdivide(dev, dmap_in, fact);
747 if (ret < 0)
748 return ret;
749 break;
750
751 case SNDCTL_DSP_GETISPACE:
752 case SNDCTL_DSP_GETOSPACE:
753 dmap = dmap_out;
754 if (cmd == SNDCTL_DSP_GETISPACE && !(audio_devs[dev]->open_mode & OPEN_READ))
755 return -EINVAL;
756 if (cmd == SNDCTL_DSP_GETOSPACE && !(audio_devs[dev]->open_mode & OPEN_WRITE))
757 return -EINVAL;
758 if (cmd == SNDCTL_DSP_GETISPACE && audio_devs[dev]->flags & DMA_DUPLEX)
759 dmap = dmap_in;
760 if (dmap->mapping_flags & DMA_MAP_MAPPED)
761 return -EINVAL;
762 if (!(dmap->flags & DMA_ALLOC_DONE))
763 reorganize_buffers(dev, dmap, (cmd == SNDCTL_DSP_GETISPACE));
764 info.fragstotal = dmap->nbufs;
765 if (cmd == SNDCTL_DSP_GETISPACE)
766 info.fragments = dmap->qlen;
767 else
768 {
769 if (!DMAbuf_space_in_queue(dev))
770 info.fragments = 0;
771 else
772 {
773 info.fragments = DMAbuf_space_in_queue(dev);
774 if (audio_devs[dev]->d->local_qlen)
775 {
776 int tmp = audio_devs[dev]->d->local_qlen(dev);
777 if (tmp && info.fragments)
778 tmp--; /*
779 * This buffer has been counted twice
780 */
781 info.fragments -= tmp;
782 }
783 }
784 }
785 if (info.fragments < 0)
786 info.fragments = 0;
787 else if (info.fragments > dmap->nbufs)
788 info.fragments = dmap->nbufs;
789
790 info.fragsize = dmap->fragment_size;
791 info.bytes = info.fragments * dmap->fragment_size;
792
793 if (cmd == SNDCTL_DSP_GETISPACE && dmap->qlen)
794 info.bytes -= dmap->counts[dmap->qhead];
795 else
796 {
797 info.fragments = info.bytes / dmap->fragment_size;
798 info.bytes -= dmap->user_counter % dmap->fragment_size;
799 }
800 if (copy_to_user(arg, &info, sizeof(info)))
801 return -EFAULT;
802 return 0;
803
804 case SNDCTL_DSP_SETTRIGGER:
805 if (get_user(bits, (int *)arg))
806 return -EFAULT;
807 bits &= audio_devs[dev]->open_mode;
808 if (audio_devs[dev]->d->trigger == NULL)
809 return -EINVAL;
810 if (!(audio_devs[dev]->flags & DMA_DUPLEX) && (bits & PCM_ENABLE_INPUT) &&
811 (bits & PCM_ENABLE_OUTPUT))
812 return -EINVAL;
813 save_flags(flags);
814 cli();
815 changed = audio_devs[dev]->enable_bits ^ bits;
816 if ((changed & bits) & PCM_ENABLE_INPUT && audio_devs[dev]->go)
817 {
818 reorganize_buffers(dev, dmap_in, 1);
819 if ((err = audio_devs[dev]->d->prepare_for_input(dev,
820 dmap_in->fragment_size, dmap_in->nbufs)) < 0) {
821 restore_flags(flags);
822 return -err;
823 }
824 dmap_in->dma_mode = DMODE_INPUT;
825 audio_devs[dev]->enable_bits = bits;
826 DMAbuf_activate_recording(dev, dmap_in);
827 }
828 if ((changed & bits) & PCM_ENABLE_OUTPUT &&
829 (dmap_out->mapping_flags & DMA_MAP_MAPPED || dmap_out->qlen > 0) &&
830 audio_devs[dev]->go)
831 {
832 if (!(dmap_out->flags & DMA_ALLOC_DONE))
833 reorganize_buffers(dev, dmap_out, 0);
834 dmap_out->dma_mode = DMODE_OUTPUT;
835 audio_devs[dev]->enable_bits = bits;
836 dmap_out->counts[dmap_out->qhead] = dmap_out->fragment_size;
837 DMAbuf_launch_output(dev, dmap_out);
838 }
839 audio_devs[dev]->enable_bits = bits;
840 #if 0
841 if (changed && audio_devs[dev]->d->trigger)
842 audio_devs[dev]->d->trigger(dev, bits * audio_devs[dev]->go);
843 #endif
844 restore_flags(flags);
845 /* Falls through... */
846
847 case SNDCTL_DSP_GETTRIGGER:
848 ret = audio_devs[dev]->enable_bits;
849 break;
850
851 case SNDCTL_DSP_SETSYNCRO:
852 if (!audio_devs[dev]->d->trigger)
853 return -EINVAL;
854 audio_devs[dev]->d->trigger(dev, 0);
855 audio_devs[dev]->go = 0;
856 return 0;
857
858 case SNDCTL_DSP_GETIPTR:
859 if (!(audio_devs[dev]->open_mode & OPEN_READ))
860 return -EINVAL;
861 save_flags(flags);
862 cli();
863 cinfo.bytes = dmap_in->byte_counter;
864 cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_in, DMODE_INPUT) & ~3;
865 if (cinfo.ptr < dmap_in->fragment_size && dmap_in->qtail != 0)
866 cinfo.bytes += dmap_in->bytes_in_use; /* Pointer wrap not handled yet */
867 cinfo.blocks = dmap_in->qlen;
868 cinfo.bytes += cinfo.ptr;
869 if (dmap_in->mapping_flags & DMA_MAP_MAPPED)
870 dmap_in->qlen = 0; /* Reset interrupt counter */
871 restore_flags(flags);
872 if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
873 return -EFAULT;
874 return 0;
875
876 case SNDCTL_DSP_GETOPTR:
877 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
878 return -EINVAL;
879
880 save_flags(flags);
881 cli();
882 cinfo.bytes = dmap_out->byte_counter;
883 cinfo.ptr = DMAbuf_get_buffer_pointer(dev, dmap_out, DMODE_OUTPUT) & ~3;
884 if (cinfo.ptr < dmap_out->fragment_size && dmap_out->qhead != 0)
885 cinfo.bytes += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
886 cinfo.blocks = dmap_out->qlen;
887 cinfo.bytes += cinfo.ptr;
888 if (dmap_out->mapping_flags & DMA_MAP_MAPPED)
889 dmap_out->qlen = 0; /* Reset interrupt counter */
890 restore_flags(flags);
891 if (copy_to_user(arg, &cinfo, sizeof(cinfo)))
892 return -EFAULT;
893 return 0;
894
895 case SNDCTL_DSP_GETODELAY:
896 if (!(audio_devs[dev]->open_mode & OPEN_WRITE))
897 return -EINVAL;
898 if (!(dmap_out->flags & DMA_ALLOC_DONE))
899 {
900 ret=0;
901 break;
902 }
903 save_flags(flags);
904 cli();
905 /* Compute number of bytes that have been played */
906 count = DMAbuf_get_buffer_pointer (dev, dmap_out, DMODE_OUTPUT);
907 if (count < dmap_out->fragment_size && dmap_out->qhead != 0)
908 count += dmap_out->bytes_in_use; /* Pointer wrap not handled yet */
909 count += dmap_out->byte_counter;
910 /* Substract current count from the number of bytes written by app */
911 count = dmap_out->user_counter - count;
912 if (count < 0)
913 count = 0;
914 restore_flags (flags);
915 ret = count;
916 break;
917
918 case SNDCTL_DSP_POST:
919 if (audio_devs[dev]->dmap_out->qlen > 0)
920 if (!(audio_devs[dev]->dmap_out->flags & DMA_ACTIVE))
921 DMAbuf_launch_output(dev, audio_devs[dev]->dmap_out);
922 return 0;
923
924 case SNDCTL_DSP_GETBLKSIZE:
925 dmap = dmap_out;
926 if (audio_devs[dev]->open_mode & OPEN_WRITE)
927 reorganize_buffers(dev, dmap_out, (audio_devs[dev]->open_mode == OPEN_READ));
928 if (audio_devs[dev]->open_mode == OPEN_READ ||
929 (audio_devs[dev]->flags & DMA_DUPLEX &&
930 audio_devs[dev]->open_mode & OPEN_READ))
931 reorganize_buffers(dev, dmap_in, (audio_devs[dev]->open_mode == OPEN_READ));
932 if (audio_devs[dev]->open_mode == OPEN_READ)
933 dmap = dmap_in;
934 ret = dmap->fragment_size;
935 break;
936
937 case SNDCTL_DSP_SETFRAGMENT:
938 ret = 0;
939 if (get_user(fact, (int *)arg))
940 return -EFAULT;
941 if (audio_devs[dev]->open_mode & OPEN_WRITE)
942 ret = dma_set_fragment(dev, dmap_out, fact);
943 if (ret < 0)
944 return ret;
945 if (audio_devs[dev]->open_mode == OPEN_READ ||
946 (audio_devs[dev]->flags & DMA_DUPLEX &&
947 audio_devs[dev]->open_mode & OPEN_READ))
948 ret = dma_set_fragment(dev, dmap_in, fact);
949 if (ret < 0)
950 return ret;
951 if (!arg) /* don't know what this is good for, but preserve old semantics */
952 return 0;
953 break;
954
955 default:
956 if (!audio_devs[dev]->d->ioctl)
957 return -EINVAL;
958 return audio_devs[dev]->d->ioctl(dev, cmd, arg);
959 }
960 return put_user(ret, (int *)arg);
961 }
962
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.