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