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