2 * linux/drivers/sound/soundcard.c
4 * Soundcard driver for Linux
7 * Copyright (C) by Hannu Savolainen 1993-1997
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
15 * integrated sound_switch.c
16 * Stefan Reinauer : integrated /proc/sound (equals to /dev/sndstat,
17 * which should disappear in the near future)
19 #include <linux/config.h>
22 #include "sound_config.h"
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/signal.h>
26 #include <linux/fcntl.h>
27 #include <linux/ctype.h>
30 #include <asm/segment.h>
31 #include <linux/wait.h>
32 #include <linux/malloc.h>
33 #include <linux/ioport.h>
34 #endif /* __KERNEL__ */
35 #include <linux/delay.h>
36 #include <linux/proc_fs.h>
40 #include "soundmodule.h"
42 #include <linux/major.h>
49 static int chrdev_registered
= 0;
50 static int sound_major
= SOUND_MAJOR
;
52 static int is_unloading
= 0;
55 * Table for permanently allocated memory (used when unloading the module)
57 caddr_t sound_mem_blocks
[1024];
58 int sound_mem_sizes
[1024];
59 int sound_nblocks
= 0;
61 static int soundcard_configured
= 0;
63 static struct fileinfo files
[SND_NDEVS
];
65 static char dma_alloc_map
[8] =
68 #define DMA_MAP_UNAVAIL 0
69 #define DMA_MAP_FREE 1
70 #define DMA_MAP_BUSY 2
73 static int in_use
= 0; /* Total # of open devices */
74 unsigned long seq_time
= 0; /* Time for /dev/sequencer */
77 * Table for configurable mixer volume handling
79 static mixer_vol_table mixer_vols
[MAX_MIXER_DEV
];
80 static int num_mixer_volumes
= 0;
83 int *load_mixer_volumes(char *name
, int *levels
, int present
)
87 for (i
= 0; i
< num_mixer_volumes
; i
++)
88 if (strcmp(name
, mixer_vols
[i
].name
) == 0)
91 mixer_vols
[i
].num
= i
;
92 return mixer_vols
[i
].levels
;
94 if (num_mixer_volumes
>= MAX_MIXER_DEV
)
96 printk("Sound: Too many mixers (%s)\n", name
);
99 n
= num_mixer_volumes
++;
101 strcpy(mixer_vols
[n
].name
, name
);
104 mixer_vols
[n
].num
= n
;
106 mixer_vols
[n
].num
= -1;
108 for (i
= 0; i
< 32; i
++)
109 mixer_vols
[n
].levels
[i
] = levels
[i
];
110 return mixer_vols
[n
].levels
;
113 static int set_mixer_levels(caddr_t arg
)
115 /* mixer_vol_table is 174 bytes, so IMHO no reason to not allocate it on the stack */
118 if (__copy_from_user(&buf
, arg
, sizeof(buf
)))
120 load_mixer_volumes(buf
.name
, buf
.levels
, 0);
121 return __copy_to_user(arg
, &buf
, sizeof(buf
));
124 static int get_mixer_levels(caddr_t arg
)
128 if (__get_user(n
, (int *)(&(((mixer_vol_table
*)arg
)->num
))))
130 if (n
< 0 || n
>= num_mixer_volumes
)
132 return __copy_to_user(arg
, &mixer_vols
[n
], sizeof(mixer_vol_table
));
135 static int sound_proc_get_info(char *buffer
, char **start
, off_t offset
, int length
, int inout
)
142 #define MODULEPROCSTRING "Driver loaded as a module"
144 #define MODULEPROCSTRING "Driver compiled into kernel"
147 len
= sprintf(buffer
, "OSS/Free:" SOUND_VERSION_STRING
"\n"
148 "Load type: " MODULEPROCSTRING
"\n"
149 "Kernel: %s %s %s %s %s\n"
150 "Config options: %x\n\nInstalled drivers: \n",
151 system_utsname
.sysname
, system_utsname
.nodename
, system_utsname
.release
,
152 system_utsname
.version
, system_utsname
.machine
, SELECTED_SOUND_OPTIONS
);
154 for (i
= 0; (i
< num_sound_drivers
) && (pos
<= offset
+ length
); i
++) {
155 if (!sound_drivers
[i
].card_type
)
157 len
+= sprintf(buffer
+ len
, "Type %d: %s\n",
158 sound_drivers
[i
].card_type
, sound_drivers
[i
].name
);
165 len
+= sprintf(buffer
+ len
, "\nCard config: \n");
167 for (i
= 0; (i
< num_sound_cards
) && (pos
<= offset
+ length
); i
++) {
168 if (!snd_installed_cards
[i
].card_type
)
170 if (!snd_installed_cards
[i
].enabled
)
171 len
+= sprintf(buffer
+ len
, "(");
172 if ((drv
= snd_find_driver(snd_installed_cards
[i
].card_type
)) != -1)
173 len
+= sprintf(buffer
+ len
, "%s", sound_drivers
[drv
].name
);
174 if (snd_installed_cards
[i
].config
.io_base
)
175 len
+= sprintf(buffer
+ len
, " at 0x%x", snd_installed_cards
[i
].config
.io_base
);
176 if (snd_installed_cards
[i
].config
.irq
!= 0)
177 len
+= sprintf(buffer
+ len
, " irq %d", abs(snd_installed_cards
[i
].config
.irq
));
178 if (snd_installed_cards
[i
].config
.dma
!= -1) {
179 len
+= sprintf(buffer
+ len
, " drq %d", snd_installed_cards
[i
].config
.dma
);
180 if (snd_installed_cards
[i
].config
.dma2
!= -1)
181 len
+= sprintf(buffer
+ len
, ",%d", snd_installed_cards
[i
].config
.dma2
);
183 if (!snd_installed_cards
[i
].enabled
)
184 len
+= sprintf(buffer
+ len
, ")");
185 len
+= sprintf(buffer
+ len
, "\n");
193 len
+= sprintf(buffer
+ len
, "\n\n***** Sound driver not started *****\n\n");
195 len
+= sprintf(buffer
+ len
, "\nAudio devices: NOT ENABLED IN CONFIG\n");
197 len
+= sprintf(buffer
+ len
, "\nAudio devices:\n");
198 for (i
= 0; (i
< num_audiodevs
) && (pos
<= offset
+ length
); i
++) {
199 if (audio_devs
[i
] == NULL
)
201 len
+= sprintf(buffer
+ len
, "%d: %s%s\n", i
, audio_devs
[i
]->name
,
202 audio_devs
[i
]->flags
& DMA_DUPLEX
? " (DUPLEX)" : "");
211 #ifndef CONFIG_SEQUENCER
212 len
+= sprintf(buffer
+ len
, "\nSynth devices: NOT ENABLED IN CONFIG\n");
214 len
+= sprintf(buffer
+ len
, "\nSynth devices:\n");
215 for (i
= 0; (i
< num_synths
) && (pos
<= offset
+ length
); i
++) {
216 if (synth_devs
[i
] == NULL
)
218 len
+= sprintf(buffer
+ len
, "%d: %s\n", i
, synth_devs
[i
]->info
->name
);
228 len
+= sprintf(buffer
+ len
, "\nMidi devices: NOT ENABLED IN CONFIG\n");
230 len
+= sprintf(buffer
+ len
, "\nMidi devices:\n");
231 for (i
= 0; (i
< num_midis
) && (pos
<= offset
+ length
); i
++) {
232 if (midi_devs
[i
] == NULL
)
234 len
+= sprintf(buffer
+ len
, "%d: %s\n", i
, midi_devs
[i
]->info
.name
);
243 #ifdef CONFIG_SEQUENCER
244 len
+= sprintf(buffer
+ len
, "\nTimers:\n");
246 for (i
= 0; (i
< num_sound_timers
) && (pos
<= offset
+ length
); i
++) {
247 if (sound_timer_devs
[i
] == NULL
)
249 len
+= sprintf(buffer
+ len
, "%d: %s\n", i
, sound_timer_devs
[i
]->info
.name
);
258 len
+= sprintf(buffer
+ len
, "\nMixers:\n");
259 for (i
= 0; (i
< num_mixers
) && (pos
<= offset
+ length
); i
++) {
260 if (mixer_devs
[i
] == NULL
)
262 len
+= sprintf(buffer
+ len
, "%d: %s\n", i
, mixer_devs
[i
]->name
);
269 *start
= buffer
+ (offset
- begin
);
270 len
-= (offset
- begin
);
276 static struct proc_dir_entry proc_root_sound
= {
277 PROC_SOUND
, 5, "sound",
278 S_IFREG
| S_IRUGO
, 1, 0, 0,
279 0, NULL
, sound_proc_get_info
283 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
286 /* 4K page size but our output routines use some slack for overruns */
287 #define PROC_BLOCK_SIZE (3*1024)
290 * basically copied from fs/proc/generic.c:proc_file_read
291 * should be removed sometime in the future together with /dev/sndstat
292 * (a symlink /dev/sndstat -> /proc/sound will do as well)
294 static ssize_t
sndstat_file_read(struct file
* file
, char * buf
, size_t nbytes
, loff_t
*ppos
)
302 if (!(page
= (char*) __get_free_page(GFP_KERNEL
)))
305 while ((nbytes
> 0) && !eof
)
307 count
= MIN(PROC_BLOCK_SIZE
, nbytes
);
310 n
= sound_proc_get_info(page
, &start
, *ppos
, count
, 0);
316 * For proc files that are less than 4k
318 start
= page
+ *ppos
;
326 break; /* End of file */
333 n
-= copy_to_user(buf
, start
, n
); /* BUG ??? */
340 *ppos
+= n
; /* Move down the file */
345 free_page((unsigned long) page
);
350 static ssize_t
sound_read(struct file
*file
, char *buf
, size_t count
, loff_t
*ppos
)
352 int dev
= MINOR(file
->f_dentry
->d_inode
->i_rdev
);
354 files
[dev
].flags
= file
->f_flags
;
355 DEB(printk("sound_read(dev=%d, count=%d)\n", dev
, count
));
356 switch (dev
& 0x0f) {
358 return sndstat_file_read(file
, buf
, count
, ppos
);
364 return audio_read(dev
, &files
[dev
], buf
, count
);
367 #ifdef CONFIG_SEQUENCER
370 return sequencer_read(dev
, &files
[dev
], buf
, count
);
375 return MIDIbuf_read(dev
, &files
[dev
], buf
, count
);
383 static ssize_t
sound_write(struct file
*file
, const char *buf
, size_t count
, loff_t
*ppos
)
385 int dev
= MINOR(file
->f_dentry
->d_inode
->i_rdev
);
387 files
[dev
].flags
= file
->f_flags
;
388 DEB(printk("sound_write(dev=%d, count=%d)\n", dev
, count
));
389 switch (dev
& 0x0f) {
390 #ifdef CONFIG_SEQUENCER
393 return sequencer_write(dev
, &files
[dev
], buf
, count
);
400 return audio_write(dev
, &files
[dev
], buf
, count
);
405 return MIDIbuf_write(dev
, &files
[dev
], buf
, count
);
411 static long long sound_lseek(struct file
*file
, long long offset
, int orig
)
416 static int sound_open(struct inode
*inode
, struct file
*file
)
419 struct fileinfo tmp_file
;
422 /* printk(KERN_ERR "Sound: Driver partially removed. Can't open device\n");*/
425 dev
= MINOR(inode
->i_rdev
);
426 if (!soundcard_configured
&& dev
!= SND_DEV_CTL
&& dev
!= SND_DEV_STATUS
) {
427 /* printk("SoundCard Error: The soundcard system has not been configured\n");*/
431 tmp_file
.flags
= file
->f_flags
;
433 if ((tmp_file
.flags
& O_ACCMODE
) == O_RDWR
)
434 tmp_file
.mode
= OPEN_READWRITE
;
435 if ((tmp_file
.flags
& O_ACCMODE
) == O_RDONLY
)
436 tmp_file
.mode
= OPEN_READ
;
437 if ((tmp_file
.flags
& O_ACCMODE
) == O_WRONLY
)
438 tmp_file
.mode
= OPEN_WRITE
;
439 DEB(printk("sound_open(dev=%d)\n", dev
));
440 if ((dev
>= SND_NDEVS
) || (dev
< 0)) {
441 printk(KERN_ERR
"Invalid minor device %d\n", dev
);
444 switch (dev
& 0x0f) {
449 if ((dev
& 0xf0) && ((dev
& 0xf0) >> 4) >= num_mixers
)
453 #ifdef CONFIG_SEQUENCER
456 if ((retval
= sequencer_open(dev
, &tmp_file
)) < 0)
463 if ((retval
= MIDIbuf_open(dev
, &tmp_file
)) < 0)
472 if ((retval
= audio_open(dev
, &tmp_file
)) < 0)
478 printk(KERN_ERR
"Invalid minor device %d\n", dev
);
485 memcpy(&files
[dev
], &tmp_file
, sizeof(tmp_file
));
489 static int sound_release(struct inode
*inode
, struct file
*file
)
491 int dev
= MINOR(inode
->i_rdev
);
493 files
[dev
].flags
= file
->f_flags
;
494 DEB(printk("sound_release(dev=%d)\n", dev
));
495 switch (dev
& 0x0f) {
500 #ifdef CONFIG_SEQUENCER
503 sequencer_release(dev
, &files
[dev
]);
509 MIDIbuf_release(dev
, &files
[dev
]);
517 audio_release(dev
, &files
[dev
]);
522 printk(KERN_ERR
"Sound error: Releasing unknown device 0x%02x\n", dev
);
531 static int get_mixer_info(int dev
, caddr_t arg
)
536 if (dev
< 0 || dev
>= num_mixers
)
538 strcpy(info
.id
, mixer_devs
[dev
]->id
);
539 for (i
= 0; i
< 32 && mixer_devs
[dev
]->name
; i
++)
540 info
.name
[i
] = mixer_devs
[dev
]->name
[i
];
542 info
.modify_counter
= mixer_devs
[dev
]->modify_counter
;
543 if (__copy_to_user(arg
, &info
, sizeof(info
)))
548 static int get_old_mixer_info(int dev
, caddr_t arg
)
550 _old_mixer_info info
;
553 if (dev
< 0 || dev
>= num_mixers
)
555 strcpy(info
.id
, mixer_devs
[dev
]->id
);
556 for (i
= 0; i
< 32 && mixer_devs
[dev
]->name
; i
++)
557 info
.name
[i
] = mixer_devs
[dev
]->name
[i
];
559 if (__copy_to_user(arg
, &info
, sizeof(info
)))
564 static int sound_mixer_ioctl(int mixdev
, unsigned int cmd
, caddr_t arg
)
566 if (cmd
== SOUND_MIXER_INFO
)
567 return get_mixer_info(mixdev
, arg
);
568 if (cmd
== SOUND_OLD_MIXER_INFO
)
569 return get_old_mixer_info(mixdev
, arg
);
570 if (_SIOC_DIR(cmd
) & _SIOC_WRITE
)
571 mixer_devs
[mixdev
]->modify_counter
++;
572 if (!mixer_devs
[mixdev
]->ioctl
)
574 return mixer_devs
[mixdev
]->ioctl(mixdev
, cmd
, arg
);
577 static int sound_ioctl(struct inode
*inode
, struct file
*file
,
578 unsigned int cmd
, unsigned long arg
)
580 int err
, len
= 0, dtype
, mixdev
;
581 int dev
= MINOR(inode
->i_rdev
);
583 files
[dev
].flags
= file
->f_flags
;
584 if (_SIOC_DIR(cmd
) != _SIOC_NONE
&& _SIOC_DIR(cmd
) != 0) {
586 * Have to validate the address given by the process.
588 len
= _SIOC_SIZE(cmd
);
589 if (len
< 1 || len
> 65536 || arg
== 0)
591 if (_SIOC_DIR(cmd
) & _SIOC_WRITE
)
592 if ((err
= verify_area(VERIFY_READ
, (void *)arg
, len
)) < 0)
594 if (_SIOC_DIR(cmd
) & _SIOC_READ
)
595 if ((err
= verify_area(VERIFY_WRITE
, (void *)arg
, len
)) < 0)
598 DEB(printk("sound_ioctl(dev=%d, cmd=0x%x, arg=0x%x)\n", dev
, cmd
, arg
));
599 if (cmd
== OSS_GETVERSION
)
600 return __put_user(SOUND_VERSION
, (int *)arg
);
602 if (((cmd
>> 8) & 0xff) == 'M' && num_mixers
> 0) /* Mixer ioctl */
603 if ((dev
& 0x0f) != SND_DEV_CTL
) {
610 mixdev
= audio_devs
[dev
>> 4]->mixer_dev
;
611 if (mixdev
< 0 || mixdev
>= num_mixers
)
613 return sound_mixer_ioctl(mixdev
, cmd
, (caddr_t
)arg
);
617 return sound_mixer_ioctl(dev
, cmd
, (caddr_t
)arg
);
620 switch (dev
& 0x0f) {
622 if (cmd
== SOUND_MIXER_GETLEVELS
)
623 return get_mixer_levels((caddr_t
)arg
);
624 if (cmd
== SOUND_MIXER_SETLEVELS
)
625 return set_mixer_levels((caddr_t
)arg
);
629 if (dev
>= num_mixers
)
631 return sound_mixer_ioctl(dev
, cmd
, (caddr_t
)arg
);
634 #ifdef CONFIG_SEQUENCER
637 return sequencer_ioctl(dev
, &files
[dev
], cmd
, (caddr_t
)arg
);
644 return audio_ioctl(dev
, &files
[dev
], cmd
, (caddr_t
)arg
);
650 return MIDIbuf_ioctl(dev
, &files
[dev
], cmd
, (caddr_t
)arg
);
658 static int sound_select(struct inode
*inode
, struct file
*file
, int sel_type
, poll_table
* wait
)
660 int dev
= MINOR(inode
->i_rdev
);
662 files
[dev
].flags
= file
->f_flags
;
663 DEB(printk("sound_select(dev=%d, type=0x%x)\n", dev
, sel_type
));
664 switch (dev
& 0x0f) {
665 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
668 return sequencer_select(dev
, &files
[dev
], sel_type
, wait
);
671 #if defined(CONFIG_MIDI)
673 return MIDIbuf_select(dev
, &files
[dev
], sel_type
, wait
);
676 #if defined(CONFIG_AUDIO) || defined(MODULE)
680 return DMAbuf_select(dev
>> 4, &files
[dev
], sel_type
, wait
);
686 static unsigned int sound_poll(struct file
*file
, poll_table
* wait
)
691 inode
= file
->f_dentry
->d_inode
;
692 if (sound_select(inode
, file
, SEL_IN
, wait
))
694 if (sound_select(inode
, file
, SEL_OUT
, wait
))
699 static int sound_mmap(struct file
*file
, struct vm_area_struct
*vma
)
703 struct dma_buffparms
*dmap
= NULL
;
704 int dev
= MINOR(file
->f_dentry
->d_inode
->i_rdev
);
706 files
[dev
].flags
= file
->f_flags
;
708 dev_class
= dev
& 0x0f;
711 if (dev_class
!= SND_DEV_DSP
&& dev_class
!= SND_DEV_DSP16
&& dev_class
!= SND_DEV_AUDIO
)
713 /* printk("Sound: mmap() not supported for other than audio devices\n");*/
716 if (vma
->vm_flags
& VM_WRITE
) /* Map write and read/write to the output buf */
717 dmap
= audio_devs
[dev
]->dmap_out
;
718 else if (vma
->vm_flags
& VM_READ
)
719 dmap
= audio_devs
[dev
]->dmap_in
;
722 /* printk("Sound: Undefined mmap() access\n");*/
728 /* printk("Sound: mmap() error. dmap == NULL\n");*/
731 if (dmap
->raw_buf
== NULL
)
733 /* printk("Sound: mmap() called when raw_buf == NULL\n");*/
736 if (dmap
->mapping_flags
)
738 /* printk("Sound: mmap() called twice for the same DMA buffer\n");*/
741 if (vma
->vm_offset
!= 0)
743 /* printk("Sound: mmap() offset must be 0.\n");*/
746 size
= vma
->vm_end
- vma
->vm_start
;
748 if (size
!= dmap
->bytes_in_use
)
750 printk(KERN_WARNING
"Sound: mmap() size = %ld. Should be %d\n", size
, dmap
->bytes_in_use
);
752 if (remap_page_range(vma
->vm_start
, virt_to_phys(dmap
->raw_buf
),
753 vma
->vm_end
- vma
->vm_start
,
757 vma
->vm_dentry
= dget(file
->f_dentry
);
759 dmap
->mapping_flags
|= DMA_MAP_MAPPED
;
761 memset(dmap
->raw_buf
,
767 static struct file_operations sound_fops
=
772 NULL
, /* sound_readdir */
788 register_chrdev(sound_major
, "sound", &sound_fops
);
789 chrdev_registered
= 1;
792 soundcard_configured
= 1;
794 sndtable_init(); /* Initialize call tables and detect cards */
798 if (sndtable_get_cardcount() == 0)
799 return; /* No cards detected */
802 #if defined(CONFIG_AUDIO)
803 if (num_audiodevs
|| modular
) /* Audio devices present */
805 audio_init_devices();
812 static unsigned int irqs
= 0;
820 for (i
= 0; i
< 31; i
++)
822 if (irqs
& (1ul << i
))
824 printk(KERN_WARNING
"Sound warning: IRQ%d was left allocated - fixed.\n", i
);
831 char kernel_version
[] = UTS_RELEASE
;
835 static int debugmem
= 0; /* switched off by default */
837 static int sound
[20] =
840 int init_module(void)
847 * "sound=" command line handling by Harald Milz.
850 while (i
< 20 && sound
[i
])
851 ints
[i
+ 1] = sound
[i
++];
855 sound_setup("sound=", ints
);
857 err
= register_chrdev(sound_major
, "sound", &sound_fops
);
860 printk(KERN_ERR
"sound: driver already loaded/included in kernel\n");
863 chrdev_registered
= 1;
866 if (sound_nblocks
>= 1024)
867 printk(KERN_ERR
"Sound warning: Deallocation table was too small.\n");
869 if (proc_register(&proc_root
, &proc_root_sound
))
870 printk(KERN_ERR
"sound: registering /proc/sound failed\n");
877 void cleanup_module(void)
885 if (proc_unregister(&proc_root
, PROC_SOUND
))
886 printk(KERN_ERR
"sound: unregistering /proc/sound failed\n");
887 if (chrdev_registered
)
888 unregister_chrdev(sound_major
, "sound");
890 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
894 #ifdef CONFIG_LOWLEVEL_SOUND
896 extern void sound_unload_lowlevel_drivers(void);
898 sound_unload_lowlevel_drivers();
901 sound_unload_drivers();
903 free_all_irqs(); /* If something was left allocated by accident */
905 for (i
= 0; i
< 8; i
++)
907 if (dma_alloc_map
[i
] != DMA_MAP_UNAVAIL
)
909 printk(KERN_ERR
"Sound: Hmm, DMA%d was left allocated - fixed\n", i
);
913 for (i
= 0; i
< sound_nblocks
; i
++)
915 vfree(sound_mem_blocks
[i
]);
921 void tenmicrosec(int *osp
)
926 int snd_set_irq_handler(int interrupt_level
, void (*iproc
) (int, void *, struct pt_regs
*), char *name
, int *osp
)
933 retcode
= request_irq(interrupt_level
, iproc
, 0, name
, NULL
);
937 printk(KERN_ERR
"Sound: IRQ%d already in use\n", interrupt_level
);
940 irqs
|= (1ul << interrupt_level
);
942 restore_flags(flags
);
946 void snd_release_irq(int vect
)
948 if (!(irqs
& (1ul << vect
)))
951 irqs
&= ~(1ul << vect
);
952 free_irq(vect
, NULL
);
955 int sound_alloc_dma(int chn
, char *deviceID
)
959 if ((err
= request_dma(chn
, deviceID
)) != 0)
962 dma_alloc_map
[chn
] = DMA_MAP_FREE
;
967 int sound_open_dma(int chn
, char *deviceID
)
971 if (chn
< 0 || chn
> 7 || chn
== 4)
973 printk(KERN_ERR
"sound_open_dma: Invalid DMA channel %d\n", chn
);
979 if (dma_alloc_map
[chn
] != DMA_MAP_FREE
)
981 printk("sound_open_dma: DMA channel %d busy or not allocated (%d)\n", chn
, dma_alloc_map
[chn
]);
982 restore_flags(flags
);
985 dma_alloc_map
[chn
] = DMA_MAP_BUSY
;
986 restore_flags(flags
);
990 void sound_free_dma(int chn
)
992 if (dma_alloc_map
[chn
] == DMA_MAP_UNAVAIL
)
994 /* printk( "sound_free_dma: Bad access to DMA channel %d\n", chn); */
998 dma_alloc_map
[chn
] = DMA_MAP_UNAVAIL
;
1001 void sound_close_dma(int chn
)
1003 unsigned long flags
;
1008 if (dma_alloc_map
[chn
] != DMA_MAP_BUSY
)
1010 printk(KERN_ERR
"sound_close_dma: Bad access to DMA channel %d\n", chn
);
1011 restore_flags(flags
);
1014 dma_alloc_map
[chn
] = DMA_MAP_FREE
;
1015 restore_flags(flags
);
1018 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
1020 static void do_sequencer_timer(unsigned long dummy
)
1026 static struct timer_list seq_timer
=
1027 {NULL
, NULL
, 0, 0, do_sequencer_timer
};
1029 void request_sound_timer(int count
)
1031 extern unsigned long seq_time
;
1035 seq_timer
.expires
= (-count
) + jiffies
;
1036 add_timer(&seq_timer
);
1046 seq_timer
.expires
= (count
) + jiffies
;
1047 add_timer(&seq_timer
);
1050 void sound_stop_timer(void)
1052 del_timer(&seq_timer
);;
1058 static int dma_buffsize
= DSP_BUFFSIZE
;
1061 sound_alloc_dmap(int dev
, struct dma_buffparms
*dmap
, int chan
)
1063 char *start_addr
, *end_addr
;
1064 int i
, dma_pagesize
;
1066 dmap
->mapping_flags
&= ~DMA_MAP_MAPPED
;
1068 if (dmap
->raw_buf
!= NULL
)
1069 return 0; /* Already done */
1071 if (dma_buffsize
< 4096)
1072 dma_buffsize
= 4096;
1075 dma_pagesize
= 64 * 1024;
1077 dma_pagesize
= 128 * 1024;
1079 dmap
->raw_buf
= NULL
;
1081 dmap
->buffsize
= dma_buffsize
;
1083 if (dmap
->buffsize
> dma_pagesize
)
1084 dmap
->buffsize
= dma_pagesize
;
1089 * Now loop until we get a free buffer. Try to get smaller buffer if
1090 * it fails. Don't accept smaller than 8k buffer for performance
1094 while (start_addr
== NULL
&& dmap
->buffsize
> PAGE_SIZE
)
1098 for (sz
= 0, size
= PAGE_SIZE
;
1099 size
< dmap
->buffsize
;
1102 dmap
->buffsize
= PAGE_SIZE
* (1 << sz
);
1104 if ((start_addr
= (char *) __get_free_pages(GFP_ATOMIC
|GFP_DMA
, sz
)) == NULL
)
1105 dmap
->buffsize
/= 2;
1108 if (start_addr
== NULL
)
1110 printk(KERN_WARNING
"Sound error: Couldn't allocate DMA buffer\n");
1115 /* make some checks */
1116 end_addr
= start_addr
+ dmap
->buffsize
- 1;
1119 printk(KERN_DEBUG
"sound: start 0x%lx, end 0x%lx\n", (long) start_addr
, (long) end_addr
);
1121 /* now check if it fits into the same dma-pagesize */
1123 if (((long) start_addr
& ~(dma_pagesize
- 1))
1124 != ((long) end_addr
& ~(dma_pagesize
- 1))
1125 || end_addr
>= (char *) (MAX_DMA_ADDRESS
))
1127 printk(KERN_ERR
"sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr
, dmap
->buffsize
);
1131 dmap
->raw_buf
= start_addr
;
1132 dmap
->raw_buf_phys
= virt_to_bus(start_addr
);
1134 for (i
= MAP_NR(start_addr
); i
<= MAP_NR(end_addr
); i
++)
1136 set_bit(PG_reserved
, &mem_map
[i
].flags
);;
1142 void sound_free_dmap(int dev
, struct dma_buffparms
*dmap
, int chan
)
1145 unsigned long start_addr
, end_addr
;
1147 if (dmap
->raw_buf
== NULL
)
1150 if (dmap
->mapping_flags
& DMA_MAP_MAPPED
)
1151 return; /* Don't free mmapped buffer. Will use it next time */
1153 for (sz
= 0, size
= PAGE_SIZE
;
1154 size
< dmap
->buffsize
;
1157 start_addr
= (unsigned long) dmap
->raw_buf
;
1158 end_addr
= start_addr
+ dmap
->buffsize
;
1160 for (i
= MAP_NR(start_addr
); i
<= MAP_NR(end_addr
); i
++)
1162 clear_bit(PG_reserved
, &mem_map
[i
].flags
);;
1165 free_pages((unsigned long) dmap
->raw_buf
, sz
);
1166 dmap
->raw_buf
= NULL
;
1170 /* Intel version !!!!!!!!! */
1172 int sound_start_dma(int dev
, struct dma_buffparms
*dmap
, int chan
,
1173 unsigned long physaddr
,
1174 int count
, int dma_mode
, int autoinit
)
1176 unsigned long flags
;
1178 /* printk( "Start DMA%d %d, %d\n", chan, (int)(physaddr-dmap->raw_buf_phys), count); */
1180 dma_mode
|= DMA_AUTOINIT
;
1185 set_dma_mode(chan
, dma_mode
);
1186 set_dma_addr(chan
, physaddr
);
1187 set_dma_count(chan
, count
);
1189 restore_flags(flags
);
1196 void conf_printf(char *name
, struct address_info
*hw_config
)
1201 printk("<%s> at 0x%03x", name
, hw_config
->io_base
);
1204 printk(" irq %d", (hw_config
->irq
> 0) ? hw_config
->irq
: -hw_config
->irq
);
1206 if (hw_config
->dma
!= -1 || hw_config
->dma2
!= -1)
1208 printk(" dma %d", hw_config
->dma
);
1209 if (hw_config
->dma2
!= -1)
1210 printk(",%d", hw_config
->dma2
);
1215 void conf_printf2(char *name
, int base
, int irq
, int dma
, int dma2
)
1220 printk("<%s> at 0x%03x", name
, base
);
1223 printk(" irq %d", (irq
> 0) ? irq
: -irq
);
1225 if (dma
!= -1 || dma2
!= -1)
1227 printk(" dma %d", dma
);
1229 printk(",%d", dma2
);
1235 * Module and lock management
1238 struct notifier_block
*sound_locker
=(struct notifier_block
*)0;
1239 static int lock_depth
= 0;
1241 #define SOUND_INC_USE_COUNT do { notifier_call_chain(&sound_locker, 1, 0); lock_depth++; } while(0);
1242 #define SOUND_DEC_USE_COUNT do { notifier_call_chain(&sound_locker, 0, 0); lock_depth--; } while(0);
1245 * When a sound module is registered we need to bring it to the current
1249 void sound_notifier_chain_register(struct notifier_block
*bl
)
1253 notifier_chain_register(&sound_locker
, bl
);
1255 * Normalise the lock count by calling the entry directly. We
1256 * have to call the module as it owns its own use counter
1258 while(ct
<lock_depth
)
1260 bl
->notifier_call(bl
, 1, 0);