1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178#include <linux/module.h>
179#include <linux/slab.h>
180#include <linux/sound.h>
181#include <linux/init.h>
182#include <linux/soundcard.h>
183#include <linux/poll.h>
184#include <linux/mutex.h>
185#include <linux/sched/signal.h>
186
187#include <linux/uaccess.h>
188
189#include "dmasound.h"
190
191#define DMASOUND_CORE_REVISION 1
192#define DMASOUND_CORE_EDITION 6
193
194
195
196
197
198static DEFINE_MUTEX(dmasound_core_mutex);
199int dmasound_catchRadius = 0;
200module_param(dmasound_catchRadius, int, 0);
201
202static unsigned int numWriteBufs = DEFAULT_N_BUFFERS;
203module_param(numWriteBufs, int, 0);
204static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ;
205module_param(writeBufSize, int, 0);
206
207MODULE_LICENSE("GPL");
208
209#ifdef MODULE
210static int sq_unit = -1;
211static int mixer_unit = -1;
212static int state_unit = -1;
213static int irq_installed;
214#endif
215
216
217static fmode_t shared_resource_owner;
218static int shared_resources_initialised;
219
220
221
222
223
224struct sound_settings dmasound = {
225 .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
226};
227
228static inline void sound_silence(void)
229{
230 dmasound.mach.silence();
231}
232
233static inline int sound_set_format(int format)
234{
235 return dmasound.mach.setFormat(format);
236}
237
238
239static int sound_set_speed(int speed)
240{
241 if (speed < 0)
242 return dmasound.soft.speed;
243
244
245
246
247
248
249 if (dmasound.mach.max_dsp_speed &&
250 (speed > dmasound.mach.max_dsp_speed))
251 speed = dmasound.mach.max_dsp_speed ;
252
253 dmasound.soft.speed = speed;
254
255 if (dmasound.minDev == SND_DEV_DSP)
256 dmasound.dsp.speed = dmasound.soft.speed;
257
258 return dmasound.soft.speed;
259}
260
261static int sound_set_stereo(int stereo)
262{
263 if (stereo < 0)
264 return dmasound.soft.stereo;
265
266 stereo = !!stereo;
267
268 dmasound.soft.stereo = stereo;
269 if (dmasound.minDev == SND_DEV_DSP)
270 dmasound.dsp.stereo = stereo;
271
272 return stereo;
273}
274
275static ssize_t sound_copy_translate(TRANS *trans, const u_char __user *userPtr,
276 size_t userCount, u_char frame[],
277 ssize_t *frameUsed, ssize_t frameLeft)
278{
279 ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t);
280
281 switch (dmasound.soft.format) {
282 case AFMT_MU_LAW:
283 ct_func = trans->ct_ulaw;
284 break;
285 case AFMT_A_LAW:
286 ct_func = trans->ct_alaw;
287 break;
288 case AFMT_S8:
289 ct_func = trans->ct_s8;
290 break;
291 case AFMT_U8:
292 ct_func = trans->ct_u8;
293 break;
294 case AFMT_S16_BE:
295 ct_func = trans->ct_s16be;
296 break;
297 case AFMT_U16_BE:
298 ct_func = trans->ct_u16be;
299 break;
300 case AFMT_S16_LE:
301 ct_func = trans->ct_s16le;
302 break;
303 case AFMT_U16_LE:
304 ct_func = trans->ct_u16le;
305 break;
306 default:
307 return 0;
308 }
309
310
311
312 if (ct_func)
313 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
314 return 0;
315}
316
317
318
319
320
321static struct {
322 int busy;
323 int modify_counter;
324} mixer;
325
326static int mixer_open(struct inode *inode, struct file *file)
327{
328 mutex_lock(&dmasound_core_mutex);
329 if (!try_module_get(dmasound.mach.owner)) {
330 mutex_unlock(&dmasound_core_mutex);
331 return -ENODEV;
332 }
333 mixer.busy = 1;
334 mutex_unlock(&dmasound_core_mutex);
335 return 0;
336}
337
338static int mixer_release(struct inode *inode, struct file *file)
339{
340 mutex_lock(&dmasound_core_mutex);
341 mixer.busy = 0;
342 module_put(dmasound.mach.owner);
343 mutex_unlock(&dmasound_core_mutex);
344 return 0;
345}
346
347static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
348{
349 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
350 mixer.modify_counter++;
351 switch (cmd) {
352 case OSS_GETVERSION:
353 return IOCTL_OUT(arg, SOUND_VERSION);
354 case SOUND_MIXER_INFO:
355 {
356 mixer_info info;
357 memset(&info, 0, sizeof(info));
358 strscpy(info.id, dmasound.mach.name2, sizeof(info.id));
359 strscpy(info.name, dmasound.mach.name2, sizeof(info.name));
360 info.modify_counter = mixer.modify_counter;
361 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
362 return -EFAULT;
363 return 0;
364 }
365 }
366 if (dmasound.mach.mixer_ioctl)
367 return dmasound.mach.mixer_ioctl(cmd, arg);
368 return -EINVAL;
369}
370
371static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
372{
373 int ret;
374
375 mutex_lock(&dmasound_core_mutex);
376 ret = mixer_ioctl(file, cmd, arg);
377 mutex_unlock(&dmasound_core_mutex);
378
379 return ret;
380}
381
382static const struct file_operations mixer_fops =
383{
384 .owner = THIS_MODULE,
385 .llseek = no_llseek,
386 .unlocked_ioctl = mixer_unlocked_ioctl,
387 .compat_ioctl = compat_ptr_ioctl,
388 .open = mixer_open,
389 .release = mixer_release,
390};
391
392static void mixer_init(void)
393{
394#ifndef MODULE
395 int mixer_unit;
396#endif
397 mixer_unit = register_sound_mixer(&mixer_fops, -1);
398 if (mixer_unit < 0)
399 return;
400
401 mixer.busy = 0;
402 dmasound.treble = 0;
403 dmasound.bass = 0;
404 if (dmasound.mach.mixer_init)
405 dmasound.mach.mixer_init();
406}
407
408
409
410
411
412
413struct sound_queue dmasound_write_sq;
414static void sq_reset_output(void) ;
415
416static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
417{
418 int i;
419
420 if (sq->buffers)
421 return 0;
422 sq->numBufs = num;
423 sq->bufSize = size;
424 sq->buffers = kmalloc_array (num, sizeof(char *), GFP_KERNEL);
425 if (!sq->buffers)
426 return -ENOMEM;
427 for (i = 0; i < num; i++) {
428 sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
429 if (!sq->buffers[i]) {
430 while (i--)
431 dmasound.mach.dma_free(sq->buffers[i], size);
432 kfree(sq->buffers);
433 sq->buffers = NULL;
434 return -ENOMEM;
435 }
436 }
437 return 0;
438}
439
440static void sq_release_buffers(struct sound_queue *sq)
441{
442 int i;
443
444 if (sq->buffers) {
445 for (i = 0; i < sq->numBufs; i++)
446 dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
447 kfree(sq->buffers);
448 sq->buffers = NULL;
449 }
450}
451
452
453static int sq_setup(struct sound_queue *sq)
454{
455 int (*setup_func)(void) = NULL;
456 int hard_frame ;
457
458 if (sq->locked) {
459#ifdef DEBUG_DMASOUND
460printk("dmasound_core: tried to sq_setup a locked queue\n") ;
461#endif
462 return -EINVAL ;
463 }
464 sq->locked = 1 ;
465
466
467
468
469
470 dmasound.mach.init();
471
472
473
474
475
476
477
478
479
480
481
482
483
484 if (sq->user_frags <= 0) {
485 sq->max_count = sq->numBufs ;
486 sq->max_active = sq->numBufs ;
487 sq->block_size = sq->bufSize;
488
489 sq->user_frags = sq->numBufs ;
490 sq->user_frag_size = sq->bufSize ;
491 sq->user_frag_size *=
492 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
493 sq->user_frag_size /=
494 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
495 } else {
496
497 sq->block_size = sq->user_frag_size ;
498 sq->block_size *=
499 (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
500 sq->block_size /=
501 (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
502
503 sq->block_size *= dmasound.hard.speed ;
504 sq->block_size /= dmasound.soft.speed ;
505
506 hard_frame =
507 (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
508 sq->block_size += (hard_frame - 1) ;
509 sq->block_size &= ~(hard_frame - 1) ;
510
511 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
512#ifdef DEBUG_DMASOUND
513printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
514#endif
515 sq->block_size = sq->bufSize ;
516 }
517 if ( sq->user_frags <= sq->numBufs ) {
518 sq->max_count = sq->user_frags ;
519
520 sq->max_active = (sq->max_active <= sq->max_count) ?
521 sq->max_active : sq->max_count ;
522 } else {
523#ifdef DEBUG_DMASOUND
524printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
525#endif
526 sq->max_count =
527 sq->max_active = sq->numBufs ;
528 }
529 }
530 sq->front = sq->count = sq->rear_size = 0;
531 sq->syncing = 0;
532 sq->active = 0;
533
534 if (sq == &write_sq) {
535 sq->rear = -1;
536 setup_func = dmasound.mach.write_sq_setup;
537 }
538 if (setup_func)
539 return setup_func();
540 return 0 ;
541}
542
543static inline void sq_play(void)
544{
545 dmasound.mach.play();
546}
547
548static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
549 loff_t *ppos)
550{
551 ssize_t uWritten = 0;
552 u_char *dest;
553 ssize_t uUsed = 0, bUsed, bLeft;
554 unsigned long flags ;
555
556
557
558
559
560 if (uLeft == 0)
561 return 0;
562
563
564
565
566
567
568 if (shared_resources_initialised == 0) {
569 dmasound.mach.init() ;
570 shared_resources_initialised = 1 ;
571 }
572
573
574
575
576
577
578
579
580 if (write_sq.locked == 0) {
581 if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
582 uWritten = 0 ;
583 }
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605 spin_lock_irqsave(&dmasound.lock, flags);
606 write_sq.syncing &= ~2 ;
607 spin_unlock_irqrestore(&dmasound.lock, flags);
608
609 if (write_sq.count > 0 &&
610 (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
611 dest = write_sq.buffers[write_sq.rear];
612 bUsed = write_sq.rear_size;
613 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
614 dest, &bUsed, bLeft);
615 if (uUsed <= 0)
616 return uUsed;
617 src += uUsed;
618 uWritten += uUsed;
619 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ;
620 write_sq.rear_size = bUsed;
621 }
622
623 while (uLeft) {
624 DEFINE_WAIT(wait);
625
626 while (write_sq.count >= write_sq.max_active) {
627 prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE);
628 sq_play();
629 if (write_sq.non_blocking) {
630 finish_wait(&write_sq.action_queue, &wait);
631 return uWritten > 0 ? uWritten : -EAGAIN;
632 }
633 if (write_sq.count < write_sq.max_active)
634 break;
635
636 schedule_timeout(HZ);
637 if (signal_pending(current)) {
638 finish_wait(&write_sq.action_queue, &wait);
639 return uWritten > 0 ? uWritten : -EINTR;
640 }
641 }
642
643 finish_wait(&write_sq.action_queue, &wait);
644
645
646
647
648
649
650
651
652 dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
653 bUsed = 0;
654 bLeft = write_sq.block_size;
655 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
656 dest, &bUsed, bLeft);
657 if (uUsed <= 0)
658 break;
659 src += uUsed;
660 uWritten += uUsed;
661 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ;
662 if (bUsed) {
663 write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
664 write_sq.rear_size = bUsed;
665 write_sq.count++;
666 }
667 }
668
669 sq_play();
670
671 return uUsed < 0? uUsed: uWritten;
672}
673
674static __poll_t sq_poll(struct file *file, struct poll_table_struct *wait)
675{
676 __poll_t mask = 0;
677 int retVal;
678
679 if (write_sq.locked == 0) {
680 if ((retVal = sq_setup(&write_sq)) < 0)
681 return retVal;
682 return 0;
683 }
684 if (file->f_mode & FMODE_WRITE )
685 poll_wait(file, &write_sq.action_queue, wait);
686 if (file->f_mode & FMODE_WRITE)
687 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
688 mask |= EPOLLOUT | EPOLLWRNORM;
689 return mask;
690
691}
692
693static inline void sq_init_waitqueue(struct sound_queue *sq)
694{
695 init_waitqueue_head(&sq->action_queue);
696 init_waitqueue_head(&sq->open_queue);
697 init_waitqueue_head(&sq->sync_queue);
698 sq->busy = 0;
699}
700
701#if 0
702static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
703 fmode_t mode)
704{
705 if (file->f_mode & mode) {
706 sq->busy = 0;
707 WAKE_UP(sq->open_queue);
708 }
709}
710#endif
711
712static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
713 int numbufs, int bufsize)
714{
715 int rc = 0;
716
717 if (file->f_mode & mode) {
718 if (sq->busy) {
719#if 0
720 rc = -EBUSY;
721 if (file->f_flags & O_NONBLOCK)
722 return rc;
723 rc = -EINTR;
724 if (wait_event_interruptible(sq->open_queue, !sq->busy))
725 return rc;
726 rc = 0;
727#else
728
729
730
731 return -EBUSY ;
732#endif
733 }
734 sq->busy = 1;
735
736
737
738
739
740
741 if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
742#if 0
743 sq_wake_up(sq, file, mode);
744#else
745 sq->busy = 0 ;
746#endif
747 return rc;
748 }
749
750 sq->non_blocking = file->f_flags & O_NONBLOCK;
751 }
752 return rc;
753}
754
755#define write_sq_init_waitqueue() sq_init_waitqueue(&write_sq)
756#if 0
757#define write_sq_wake_up(file) sq_wake_up(&write_sq, file, FMODE_WRITE)
758#endif
759#define write_sq_release_buffers() sq_release_buffers(&write_sq)
760#define write_sq_open(file) \
761 sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
762
763static int sq_open(struct inode *inode, struct file *file)
764{
765 int rc;
766
767 mutex_lock(&dmasound_core_mutex);
768 if (!try_module_get(dmasound.mach.owner)) {
769 mutex_unlock(&dmasound_core_mutex);
770 return -ENODEV;
771 }
772
773 rc = write_sq_open(file);
774 if (rc)
775 goto out;
776 if (file->f_mode & FMODE_READ) {
777
778 rc = -ENXIO ;
779 goto out;
780 }
781
782 if (dmasound.mach.sq_open)
783 dmasound.mach.sq_open(file->f_mode);
784
785
786
787
788
789 dmasound.minDev = iminor(inode) & 0x0f;
790
791
792
793
794
795
796 if (shared_resource_owner == 0) {
797
798
799 dmasound.soft = dmasound.mach.default_soft ;
800 dmasound.dsp = dmasound.mach.default_soft ;
801 dmasound.hard = dmasound.mach.default_hard ;
802 }
803
804#ifndef DMASOUND_STRICT_OSS_COMPLIANCE
805
806
807
808 if (dmasound.minDev == SND_DEV_AUDIO) {
809 sound_set_speed(8000);
810 sound_set_stereo(0);
811 sound_set_format(AFMT_MU_LAW);
812 }
813#endif
814 mutex_unlock(&dmasound_core_mutex);
815 return 0;
816 out:
817 module_put(dmasound.mach.owner);
818 mutex_unlock(&dmasound_core_mutex);
819 return rc;
820}
821
822static void sq_reset_output(void)
823{
824 sound_silence();
825 write_sq.active = 0;
826 write_sq.count = 0;
827 write_sq.rear_size = 0;
828
829 write_sq.front = 0 ;
830 write_sq.rear = -1 ;
831
832
833 write_sq.locked = 0 ;
834 write_sq.user_frags = 0 ;
835 write_sq.user_frag_size = 0 ;
836}
837
838static void sq_reset(void)
839{
840 sq_reset_output() ;
841
842
843
844
845
846 shared_resources_initialised = 0 ;
847}
848
849static int sq_fsync(void)
850{
851 int rc = 0;
852 int timeout = 5;
853
854 write_sq.syncing |= 1;
855 sq_play();
856
857 while (write_sq.active) {
858 wait_event_interruptible_timeout(write_sq.sync_queue,
859 !write_sq.active, HZ);
860 if (signal_pending(current)) {
861
862
863
864 sq_reset_output();
865 rc = -EINTR;
866 break;
867 }
868 if (!--timeout) {
869 printk(KERN_WARNING "dmasound: Timeout draining output\n");
870 sq_reset_output();
871 rc = -EIO;
872 break;
873 }
874 }
875
876
877 write_sq.syncing = 0 ;
878 return rc;
879}
880
881static int sq_release(struct inode *inode, struct file *file)
882{
883 int rc = 0;
884
885 mutex_lock(&dmasound_core_mutex);
886
887 if (file->f_mode & FMODE_WRITE) {
888 if (write_sq.busy)
889 rc = sq_fsync();
890
891 sq_reset_output() ;
892 write_sq_release_buffers();
893 write_sq.busy = 0;
894 }
895
896 if (file->f_mode & shared_resource_owner) {
897 shared_resource_owner = 0 ;
898 shared_resources_initialised = 0 ;
899 dmasound.hard = dmasound.mach.default_hard ;
900 }
901
902 module_put(dmasound.mach.owner);
903
904#if 0
905
906
907
908
909
910
911
912 read_sq_wake_up(file);
913 write_sq_wake_up(file);
914#endif
915
916 mutex_unlock(&dmasound_core_mutex);
917
918 return rc;
919}
920
921
922
923
924
925
926
927
928static int shared_resources_are_mine(fmode_t md)
929{
930 if (shared_resource_owner)
931 return (shared_resource_owner & md) != 0;
932 else {
933 shared_resource_owner = md ;
934 return 1 ;
935 }
936}
937
938
939
940
941static int queues_are_quiescent(void)
942{
943 if (write_sq.locked)
944 return 0 ;
945 return 1 ;
946}
947
948
949
950
951
952
953
954
955
956
957
958static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
959{
960 if (sq->locked) {
961#ifdef DEBUG_DMASOUND
962printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
963#endif
964 return -EINVAL ;
965 }
966
967 if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
968 return -EINVAL ;
969 size = (1<<size) ;
970 if (size > sq->bufSize)
971 return -EINVAL ;
972
973 if (bufs <= 0)
974 return -EINVAL ;
975 if (bufs > sq->numBufs)
976 bufs = sq->numBufs ;
977
978
979
980
981
982
983 sq->user_frags =
984 sq->max_active = bufs ;
985 sq->user_frag_size = size ;
986
987 return 0 ;
988}
989
990static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
991{
992 int val, result;
993 u_long fmt;
994 int data;
995 int size, nbufs;
996 audio_buf_info info;
997
998 switch (cmd) {
999 case SNDCTL_DSP_RESET:
1000 sq_reset();
1001 return 0;
1002 case SNDCTL_DSP_GETFMTS:
1003 fmt = dmasound.mach.hardware_afmts ;
1004 return IOCTL_OUT(arg, fmt);
1005 case SNDCTL_DSP_GETBLKSIZE:
1006
1007
1008
1009
1010
1011
1012
1013
1014 size = 0 ;
1015 if (file->f_mode & FMODE_WRITE) {
1016 if ( !write_sq.locked )
1017 sq_setup(&write_sq) ;
1018 size = write_sq.user_frag_size ;
1019 }
1020 return IOCTL_OUT(arg, size);
1021 case SNDCTL_DSP_POST:
1022
1023
1024
1025
1026
1027 write_sq.syncing |= 0x2 ;
1028 sq_play() ;
1029 return 0 ;
1030 case SNDCTL_DSP_SYNC:
1031
1032
1033
1034
1035 result = 0 ;
1036 if (file->f_mode & FMODE_WRITE) {
1037 result = sq_fsync();
1038 sq_reset_output() ;
1039 }
1040
1041 if (file->f_mode & shared_resource_owner)
1042 shared_resources_initialised = 0 ;
1043 return result ;
1044 case SOUND_PCM_READ_RATE:
1045 return IOCTL_OUT(arg, dmasound.soft.speed);
1046 case SNDCTL_DSP_SPEED:
1047
1048
1049
1050
1051
1052
1053 if (shared_resources_are_mine(file->f_mode)) {
1054 IOCTL_IN(arg, data);
1055 data = sound_set_speed(data) ;
1056 shared_resources_initialised = 0 ;
1057 return IOCTL_OUT(arg, data);
1058 } else
1059 return -EINVAL ;
1060 break ;
1061
1062
1063
1064
1065
1066 case SNDCTL_DSP_STEREO:
1067 if (shared_resources_are_mine(file->f_mode) &&
1068 queues_are_quiescent()) {
1069 IOCTL_IN(arg, data);
1070 shared_resources_initialised = 0 ;
1071 return IOCTL_OUT(arg, sound_set_stereo(data));
1072 } else
1073 return -EINVAL ;
1074 break ;
1075 case SOUND_PCM_WRITE_CHANNELS:
1076 if (shared_resources_are_mine(file->f_mode) &&
1077 queues_are_quiescent()) {
1078 IOCTL_IN(arg, data);
1079
1080 shared_resources_initialised = 0 ;
1081 return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1082 } else
1083 return -EINVAL ;
1084 break ;
1085 case SNDCTL_DSP_SETFMT:
1086 if (shared_resources_are_mine(file->f_mode) &&
1087 queues_are_quiescent()) {
1088 int format;
1089 IOCTL_IN(arg, data);
1090 shared_resources_initialised = 0 ;
1091 format = sound_set_format(data);
1092 result = IOCTL_OUT(arg, format);
1093 if (result < 0)
1094 return result;
1095 if (format != data && data != AFMT_QUERY)
1096 return -EINVAL;
1097 return 0;
1098 } else
1099 return -EINVAL ;
1100 case SNDCTL_DSP_SUBDIVIDE:
1101 return -EINVAL ;
1102 case SNDCTL_DSP_SETFRAGMENT:
1103
1104
1105
1106
1107
1108
1109 IOCTL_IN(arg, data);
1110 result = 0 ;
1111 nbufs = (data >> 16) & 0x7fff ;
1112 size = data & 0xffff;
1113 if (file->f_mode & FMODE_WRITE) {
1114 result = set_queue_frags(&write_sq, nbufs, size) ;
1115 if (result)
1116 return result ;
1117 }
1118
1119
1120
1121 return IOCTL_OUT(arg, data);
1122 case SNDCTL_DSP_GETOSPACE:
1123
1124
1125 if (file->f_mode & FMODE_WRITE) {
1126 if ( !write_sq.locked )
1127 sq_setup(&write_sq) ;
1128 info.fragments = write_sq.max_active - write_sq.count;
1129 info.fragstotal = write_sq.max_active;
1130 info.fragsize = write_sq.user_frag_size;
1131 info.bytes = info.fragments * info.fragsize;
1132 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1133 return -EFAULT;
1134 return 0;
1135 } else
1136 return -EINVAL ;
1137 break ;
1138 case SNDCTL_DSP_GETCAPS:
1139 val = dmasound.mach.capabilities & 0xffffff00;
1140 return IOCTL_OUT(arg,val);
1141
1142 default:
1143 return mixer_ioctl(file, cmd, arg);
1144 }
1145 return -EINVAL;
1146}
1147
1148static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
1149{
1150 int ret;
1151
1152 mutex_lock(&dmasound_core_mutex);
1153 ret = sq_ioctl(file, cmd, arg);
1154 mutex_unlock(&dmasound_core_mutex);
1155
1156 return ret;
1157}
1158
1159static const struct file_operations sq_fops =
1160{
1161 .owner = THIS_MODULE,
1162 .llseek = no_llseek,
1163 .write = sq_write,
1164 .poll = sq_poll,
1165 .unlocked_ioctl = sq_unlocked_ioctl,
1166 .compat_ioctl = compat_ptr_ioctl,
1167 .open = sq_open,
1168 .release = sq_release,
1169};
1170
1171static int sq_init(void)
1172{
1173 const struct file_operations *fops = &sq_fops;
1174#ifndef MODULE
1175 int sq_unit;
1176#endif
1177
1178 sq_unit = register_sound_dsp(fops, -1);
1179 if (sq_unit < 0) {
1180 printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1181 return sq_unit ;
1182 }
1183
1184 write_sq_init_waitqueue();
1185
1186
1187
1188
1189
1190
1191 if (shared_resource_owner == 0) {
1192 dmasound.soft = dmasound.mach.default_soft ;
1193 dmasound.hard = dmasound.mach.default_hard ;
1194 dmasound.dsp = dmasound.mach.default_soft ;
1195 shared_resources_initialised = 0 ;
1196 }
1197 return 0 ;
1198}
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210#define STAT_BUFF_LEN 768
1211
1212
1213
1214
1215
1216
1217#define LOW_LEVEL_STAT_ALLOC 162
1218
1219static struct {
1220 int busy;
1221 char buf[STAT_BUFF_LEN];
1222 int len, ptr;
1223} state;
1224
1225
1226
1227static char *get_afmt_string(int afmt)
1228{
1229 switch(afmt) {
1230 case AFMT_MU_LAW:
1231 return "mu-law";
1232 case AFMT_A_LAW:
1233 return "A-law";
1234 case AFMT_U8:
1235 return "unsigned 8 bit";
1236 case AFMT_S8:
1237 return "signed 8 bit";
1238 case AFMT_S16_BE:
1239 return "signed 16 bit BE";
1240 case AFMT_U16_BE:
1241 return "unsigned 16 bit BE";
1242 case AFMT_S16_LE:
1243 return "signed 16 bit LE";
1244 case AFMT_U16_LE:
1245 return "unsigned 16 bit LE";
1246 case 0:
1247 return "format not set" ;
1248 default:
1249 break ;
1250 }
1251 return "ERROR: Unsupported AFMT_XXXX code" ;
1252}
1253
1254static int state_open(struct inode *inode, struct file *file)
1255{
1256 char *buffer = state.buf;
1257 int len = 0;
1258 int ret;
1259
1260 mutex_lock(&dmasound_core_mutex);
1261 ret = -EBUSY;
1262 if (state.busy)
1263 goto out;
1264
1265 ret = -ENODEV;
1266 if (!try_module_get(dmasound.mach.owner))
1267 goto out;
1268
1269 state.ptr = 0;
1270 state.busy = 1;
1271
1272 len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1273 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1274 ((dmasound.mach.version>>8) & 0x0f));
1275 len += sprintf(buffer+len,
1276 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1277 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1278 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1279
1280
1281
1282
1283
1284 if (dmasound.mach.state_info)
1285 len += dmasound.mach.state_info(buffer+len,
1286 (size_t) LOW_LEVEL_STAT_ALLOC) ;
1287
1288
1289
1290
1291
1292
1293
1294
1295 len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1296 len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1297 len += sprintf(buffer+len,"Format :%20s%20s\n",
1298 get_afmt_string(dmasound.soft.format),
1299 get_afmt_string(dmasound.hard.format));
1300
1301 len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1302 dmasound.soft.speed, dmasound.hard.speed);
1303
1304 len += sprintf(buffer+len,"Channels :%20s%20s\n",
1305 dmasound.soft.stereo ? "stereo" : "mono",
1306 dmasound.hard.stereo ? "stereo" : "mono" );
1307
1308
1309
1310 len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1311 len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1312 len += sprintf(buffer+len,"%9s:%8d%6d\n",
1313 "write", write_sq.numBufs, write_sq.bufSize) ;
1314 len += sprintf(buffer+len,
1315 "Current : MaxFrg FragSiz MaxAct Frnt Rear "
1316 "Cnt RrSize A B S L xruns\n") ;
1317 len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1318 "write", write_sq.max_count, write_sq.block_size,
1319 write_sq.max_active, write_sq.front, write_sq.rear,
1320 write_sq.count, write_sq.rear_size, write_sq.active,
1321 write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1322#ifdef DEBUG_DMASOUND
1323printk("dmasound: stat buffer used %d bytes\n", len) ;
1324#endif
1325
1326 if (len >= STAT_BUFF_LEN)
1327 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1328
1329 state.len = len;
1330 ret = 0;
1331out:
1332 mutex_unlock(&dmasound_core_mutex);
1333 return ret;
1334}
1335
1336static int state_release(struct inode *inode, struct file *file)
1337{
1338 mutex_lock(&dmasound_core_mutex);
1339 state.busy = 0;
1340 module_put(dmasound.mach.owner);
1341 mutex_unlock(&dmasound_core_mutex);
1342 return 0;
1343}
1344
1345static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1346 loff_t *ppos)
1347{
1348 int n = state.len - state.ptr;
1349 if (n > count)
1350 n = count;
1351 if (n <= 0)
1352 return 0;
1353 if (copy_to_user(buf, &state.buf[state.ptr], n))
1354 return -EFAULT;
1355 state.ptr += n;
1356 return n;
1357}
1358
1359static const struct file_operations state_fops = {
1360 .owner = THIS_MODULE,
1361 .llseek = no_llseek,
1362 .read = state_read,
1363 .open = state_open,
1364 .release = state_release,
1365};
1366
1367static int state_init(void)
1368{
1369#ifndef MODULE
1370 int state_unit;
1371#endif
1372 state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1373 if (state_unit < 0)
1374 return state_unit ;
1375 state.busy = 0;
1376 return 0 ;
1377}
1378
1379
1380
1381
1382
1383
1384
1385
1386int dmasound_init(void)
1387{
1388 int res ;
1389#ifdef MODULE
1390 if (irq_installed)
1391 return -EBUSY;
1392#endif
1393
1394
1395
1396
1397 if ((res = sq_init()) < 0)
1398 return res ;
1399
1400
1401 if ((res = state_init()) < 0)
1402 return res ;
1403
1404
1405 mixer_init();
1406
1407 if (!dmasound.mach.irqinit()) {
1408 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1409 return -ENODEV;
1410 }
1411#ifdef MODULE
1412 irq_installed = 1;
1413#endif
1414
1415 printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1416 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1417 ((dmasound.mach.version>>8) & 0x0f));
1418 printk(KERN_INFO
1419 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1420 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1421 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1422 printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1423 numWriteBufs, writeBufSize) ;
1424 return 0;
1425}
1426
1427#ifdef MODULE
1428
1429void dmasound_deinit(void)
1430{
1431 if (irq_installed) {
1432 sound_silence();
1433 dmasound.mach.irqcleanup();
1434 irq_installed = 0;
1435 }
1436
1437 write_sq_release_buffers();
1438
1439 if (mixer_unit >= 0)
1440 unregister_sound_mixer(mixer_unit);
1441 if (state_unit >= 0)
1442 unregister_sound_special(state_unit);
1443 if (sq_unit >= 0)
1444 unregister_sound_dsp(sq_unit);
1445}
1446
1447#else
1448
1449static int dmasound_setup(char *str)
1450{
1451 int ints[6], size;
1452
1453 str = get_options(str, ARRAY_SIZE(ints), ints);
1454
1455
1456
1457
1458
1459
1460
1461 switch (ints[0]) {
1462 case 3:
1463 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1464 printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1465 else
1466 catchRadius = ints[3];
1467 fallthrough;
1468 case 2:
1469 if (ints[1] < MIN_BUFFERS)
1470 printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1471 else
1472 numWriteBufs = ints[1];
1473 fallthrough;
1474 case 1:
1475 if ((size = ints[2]) < 256)
1476 size <<= 10 ;
1477 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1478 printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1479 else
1480 writeBufSize = size;
1481 case 0:
1482 break;
1483 default:
1484 printk("dmasound_setup: invalid number of arguments\n");
1485 return 0;
1486 }
1487 return 1;
1488}
1489
1490__setup("dmasound=", dmasound_setup);
1491
1492#endif
1493
1494
1495
1496
1497
1498#ifdef HAS_8BIT_TABLES
1499
1500
1501char dmasound_ulaw2dma8[] = {
1502 -126, -122, -118, -114, -110, -106, -102, -98,
1503 -94, -90, -86, -82, -78, -74, -70, -66,
1504 -63, -61, -59, -57, -55, -53, -51, -49,
1505 -47, -45, -43, -41, -39, -37, -35, -33,
1506 -31, -30, -29, -28, -27, -26, -25, -24,
1507 -23, -22, -21, -20, -19, -18, -17, -16,
1508 -16, -15, -15, -14, -14, -13, -13, -12,
1509 -12, -11, -11, -10, -10, -9, -9, -8,
1510 -8, -8, -7, -7, -7, -7, -6, -6,
1511 -6, -6, -5, -5, -5, -5, -4, -4,
1512 -4, -4, -4, -4, -3, -3, -3, -3,
1513 -3, -3, -3, -3, -2, -2, -2, -2,
1514 -2, -2, -2, -2, -2, -2, -2, -2,
1515 -1, -1, -1, -1, -1, -1, -1, -1,
1516 -1, -1, -1, -1, -1, -1, -1, -1,
1517 -1, -1, -1, -1, -1, -1, -1, 0,
1518 125, 121, 117, 113, 109, 105, 101, 97,
1519 93, 89, 85, 81, 77, 73, 69, 65,
1520 62, 60, 58, 56, 54, 52, 50, 48,
1521 46, 44, 42, 40, 38, 36, 34, 32,
1522 30, 29, 28, 27, 26, 25, 24, 23,
1523 22, 21, 20, 19, 18, 17, 16, 15,
1524 15, 14, 14, 13, 13, 12, 12, 11,
1525 11, 10, 10, 9, 9, 8, 8, 7,
1526 7, 7, 6, 6, 6, 6, 5, 5,
1527 5, 5, 4, 4, 4, 4, 3, 3,
1528 3, 3, 3, 3, 2, 2, 2, 2,
1529 2, 2, 2, 2, 1, 1, 1, 1,
1530 1, 1, 1, 1, 1, 1, 1, 1,
1531 0, 0, 0, 0, 0, 0, 0, 0,
1532 0, 0, 0, 0, 0, 0, 0, 0,
1533 0, 0, 0, 0, 0, 0, 0, 0
1534};
1535
1536
1537
1538char dmasound_alaw2dma8[] = {
1539 -22, -21, -24, -23, -18, -17, -20, -19,
1540 -30, -29, -32, -31, -26, -25, -28, -27,
1541 -11, -11, -12, -12, -9, -9, -10, -10,
1542 -15, -15, -16, -16, -13, -13, -14, -14,
1543 -86, -82, -94, -90, -70, -66, -78, -74,
1544 -118, -114, -126, -122, -102, -98, -110, -106,
1545 -43, -41, -47, -45, -35, -33, -39, -37,
1546 -59, -57, -63, -61, -51, -49, -55, -53,
1547 -2, -2, -2, -2, -2, -2, -2, -2,
1548 -2, -2, -2, -2, -2, -2, -2, -2,
1549 -1, -1, -1, -1, -1, -1, -1, -1,
1550 -1, -1, -1, -1, -1, -1, -1, -1,
1551 -6, -6, -6, -6, -5, -5, -5, -5,
1552 -8, -8, -8, -8, -7, -7, -7, -7,
1553 -3, -3, -3, -3, -3, -3, -3, -3,
1554 -4, -4, -4, -4, -4, -4, -4, -4,
1555 21, 20, 23, 22, 17, 16, 19, 18,
1556 29, 28, 31, 30, 25, 24, 27, 26,
1557 10, 10, 11, 11, 8, 8, 9, 9,
1558 14, 14, 15, 15, 12, 12, 13, 13,
1559 86, 82, 94, 90, 70, 66, 78, 74,
1560 118, 114, 126, 122, 102, 98, 110, 106,
1561 43, 41, 47, 45, 35, 33, 39, 37,
1562 59, 57, 63, 61, 51, 49, 55, 53,
1563 1, 1, 1, 1, 1, 1, 1, 1,
1564 1, 1, 1, 1, 1, 1, 1, 1,
1565 0, 0, 0, 0, 0, 0, 0, 0,
1566 0, 0, 0, 0, 0, 0, 0, 0,
1567 5, 5, 5, 5, 4, 4, 4, 4,
1568 7, 7, 7, 7, 6, 6, 6, 6,
1569 2, 2, 2, 2, 2, 2, 2, 2,
1570 3, 3, 3, 3, 3, 3, 3, 3
1571};
1572#endif
1573
1574
1575
1576
1577
1578EXPORT_SYMBOL(dmasound);
1579EXPORT_SYMBOL(dmasound_init);
1580#ifdef MODULE
1581EXPORT_SYMBOL(dmasound_deinit);
1582#endif
1583EXPORT_SYMBOL(dmasound_write_sq);
1584EXPORT_SYMBOL(dmasound_catchRadius);
1585#ifdef HAS_8BIT_TABLES
1586EXPORT_SYMBOL(dmasound_ulaw2dma8);
1587EXPORT_SYMBOL(dmasound_alaw2dma8);
1588#endif
1589