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