/* * sound/oss/dev_table.c * * Device call tables. * * * Copyright (C) by Hannu Savolainen 1993-1997 * * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) * Version 2 (June 1991). See the "COPYING" file distributed with this software * for more info. */ #include <linux/init.h> #include "sound_config.h" struct audio_operations *audio_devs[MAX_AUDIO_DEV];EXPORT_SYMBOL(audio_devs); int num_audiodevs;EXPORT_SYMBOL(num_audiodevs); struct mixer_operations *mixer_devs[MAX_MIXER_DEV];EXPORT_SYMBOL(mixer_devs); int num_mixers;EXPORT_SYMBOL(num_mixers); struct synth_operations *synth_devs[MAX_SYNTH_DEV+MAX_MIDI_DEV];EXPORT_SYMBOL(synth_devs); int num_synths; struct midi_operations *midi_devs[MAX_MIDI_DEV];EXPORT_SYMBOL(midi_devs); int num_midis;EXPORT_SYMBOL(num_midis); struct sound_timer_operations *sound_timer_devs[MAX_TIMER_DEV] = {	&default_sound_timer, NULL};EXPORT_SYMBOL(sound_timer_devs); int num_sound_timers = 1;  static int sound_alloc_audiodev(void); int sound_install_audiodrv(int vers, char *name, struct audio_driver *driver,			int driver_size, int flags, unsigned int format_mask,			void *devc, int dma1, int dma2){	struct audio_driver *d;	struct audio_operations *op;	int num; 	if (vers != AUDIO_DRIVER_VERSION || driver_size > sizeof(struct audio_driver)) {		printk(KERN_ERR "Sound: Incompatible audio driver for %s\n", name);		return -EINVAL;	}	num = sound_alloc_audiodev(); 	if (num == -1) {		printk(KERN_ERR "sound: Too many audio drivers\n");		return -EBUSY;	}	d = (struct audio_driver *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct audio_driver)));	sound_nblocks++;	if (sound_nblocks >= MAX_MEM_BLOCKS)		sound_nblocks = MAX_MEM_BLOCKS - 1; 	op = (struct audio_operations *) (sound_mem_blocks[sound_nblocks] = vzalloc(sizeof(struct audio_operations)));	sound_nblocks++;	if (sound_nblocks >= MAX_MEM_BLOCKS)		sound_nblocks = MAX_MEM_BLOCKS - 1; 	if (d == NULL || op == NULL) {		printk(KERN_ERR "Sound: Can't allocate driver for (%s)\n", name);		sound_unload_audiodev(num);		return -ENOMEM;	}	init_waitqueue_head(&op->in_sleeper);	init_waitqueue_head(&op->out_sleeper);		init_waitqueue_head(&op->poll_sleeper);	if (driver_size < sizeof(struct audio_driver))		memset((char *) d, 0, sizeof(struct audio_driver)); 	memcpy((char *) d, (char *) driver, driver_size); 	op->d = d;	strlcpy(op->name, name, sizeof(op->name));	op->flags = flags;	op->format_mask = format_mask;	op->devc = devc; 	/*	 *    Hardcoded defaults	 */	audio_devs[num] = op; 	DMAbuf_init(num, dma1, dma2); 	audio_init_devices();	return num;}EXPORT_SYMBOL(sound_install_audiodrv); int sound_install_mixer(int vers, char *name, struct mixer_operations *driver,	int driver_size, void *devc){	struct mixer_operations *op; 	int n = sound_alloc_mixerdev(); 	if (n == -1) {		printk(KERN_ERR "Sound: Too many mixer drivers\n");		return -EBUSY;	}	if (vers != MIXER_DRIVER_VERSION ||		driver_size > sizeof(struct mixer_operations)) {		printk(KERN_ERR "Sound: Incompatible mixer driver for %s\n", name);		return -EINVAL;	}		/* FIXME: This leaks a mixer_operations struct every time its called	   until you unload sound! */	   	op = (struct mixer_operations *) (sound_mem_blocks[sound_nblocks] = vzalloc(sizeof(struct mixer_operations)));	sound_nblocks++;	if (sound_nblocks >= MAX_MEM_BLOCKS)		sound_nblocks = MAX_MEM_BLOCKS - 1; 	if (op == NULL) {		printk(KERN_ERR "Sound: Can't allocate mixer driver for (%s)\n", name);		return -ENOMEM;	}	memcpy((char *) op, (char *) driver, driver_size); 	strlcpy(op->name, name, sizeof(op->name));	op->devc = devc; 	mixer_devs[n] = op;	return n;}EXPORT_SYMBOL(sound_install_mixer); void sound_unload_audiodev(int dev){	if (dev != -1) {		DMAbuf_deinit(dev);		audio_devs[dev] = NULL;		unregister_sound_dsp((dev<<4)+3);	}}EXPORT_SYMBOL(sound_unload_audiodev); static int sound_alloc_audiodev(void){ 	int i = register_sound_dsp(&oss_sound_fops, -1);	if(i==-1)		return i;	i>>=4;	if(i>=num_audiodevs)		num_audiodevs = i + 1;	return i;} int sound_alloc_mididev(void){	int i = register_sound_midi(&oss_sound_fops, -1);	if(i==-1)		return i;	i>>=4;	if(i>=num_midis)		num_midis = i + 1;	return i;}EXPORT_SYMBOL(sound_alloc_mididev); int sound_alloc_synthdev(void){	int i; 	for (i = 0; i < MAX_SYNTH_DEV; i++) {		if (synth_devs[i] == NULL) {			if (i >= num_synths)				num_synths++;			return i;		}	}	return -1;}EXPORT_SYMBOL(sound_alloc_synthdev); int sound_alloc_mixerdev(void){	int i = register_sound_mixer(&oss_sound_fops, -1);	if(i==-1)		return -1;	i>>=4;	if(i>=num_mixers)		num_mixers = i + 1;	return i;}EXPORT_SYMBOL(sound_alloc_mixerdev); int sound_alloc_timerdev(void){	int i; 	for (i = 0; i < MAX_TIMER_DEV; i++) {		if (sound_timer_devs[i] == NULL) {			if (i >= num_sound_timers)				num_sound_timers++;			return i;		}	}	return -1;}EXPORT_SYMBOL(sound_alloc_timerdev); void sound_unload_mixerdev(int dev){	if (dev != -1) {		mixer_devs[dev] = NULL;		unregister_sound_mixer(dev<<4);		num_mixers--;	}}EXPORT_SYMBOL(sound_unload_mixerdev); void sound_unload_mididev(int dev){	if (dev != -1) {		midi_devs[dev] = NULL;		unregister_sound_midi((dev<<4)+2);	}}EXPORT_SYMBOL(sound_unload_mididev); void sound_unload_synthdev(int dev){	if (dev != -1)		synth_devs[dev] = NULL;}EXPORT_SYMBOL(sound_unload_synthdev); void sound_unload_timerdev(int dev){	if (dev != -1)		sound_timer_devs[dev] = NULL;}EXPORT_SYMBOL(sound_unload_timerdev);