[linux.git] / sound / sound_core.c

/*
 *	Sound core handling. Breaks out sound functions to submodules
 *	
 *	Author:		Alan Cox <[email protected]>
 *
 *	Fixes:
 *
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 *                         --------------------
 * 
 *	Top level handler for the sound subsystem. Various devices can
 *	plug into this. The fact they don't all go via OSS doesn't mean 
 *	they don't have to implement the OSS API. There is a lot of logic
 *	to keeping much of the OSS weight out of the code in a compatibility
 *	module, but it's up to the driver to rember to load it...
 *
 *	The code provides a set of functions for registration of devices
 *	by type. This is done rather than providing a single call so that
 *	we can hide any future changes in the internals (eg when we go to
 *	32bit dev_t) from the modules and their interface.
 *
 *	Secondly we need to allocate the dsp, dsp16 and audio devices as
 *	one. Thus we misuse the chains a bit to simplify this.
 *
 *	Thirdly to make it more fun and for 2.3.x and above we do all
 *	of this using fine grained locking.
 *
 *	FIXME: we have to resolve modules and fine grained load/unload
 *	locking at some point in 2.3.x.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/sound.h>
#include <linux/major.h>
#include <linux/kmod.h>
#include <linux/device.h>

#define SOUND_STEP 16


struct sound_unit
{
	int unit_minor;
	const struct file_operations *unit_fops;
	struct sound_unit *next;
	char name[32];
};

#ifdef CONFIG_SOUND_MSNDCLAS
extern int msnd_classic_init(void);
#endif
#ifdef CONFIG_SOUND_MSNDPIN
extern int msnd_pinnacle_init(void);
#endif

struct class *sound_class;
EXPORT_SYMBOL(sound_class);

/*
 *	Low level list operator. Scan the ordered list, find a hole and
 *	join into it. Called with the lock asserted
 */

static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, const struct file_operations *fops, int index, int low, int top)
{
	int n=low;

	if (index < 0) {	/* first free */

		while (*list && (*list)->unit_minor<n)
			list=&((*list)->next);

		while(n<top)
		{
			/* Found a hole ? */
			if(*list==NULL || (*list)->unit_minor>n)
				break;
			list=&((*list)->next);
			n+=SOUND_STEP;
		}

		if(n>=top)
			return -ENOENT;
	} else {
		n = low+(index*16);
		while (*list) {
			if ((*list)->unit_minor==n)
				return -EBUSY;
			if ((*list)->unit_minor>n)
				break;
			list=&((*list)->next);
		}
	}	
		
	/*
	 *	Fill it in
	 */
	 
	s->unit_minor=n;
	s->unit_fops=fops;
	
	/*
	 *	Link it
	 */
	 
	s->next=*list;
	*list=s;
	
	
	return n;
}

/*
 *	Remove a node from the chain. Called with the lock asserted
 */
 
static struct sound_unit *__sound_remove_unit(struct sound_unit **list, int unit)
{
	while(*list)
	{
		struct sound_unit *p=*list;
		if(p->unit_minor==unit)
		{
			*list=p->next;
			return p;
		}
		list=&(p->next);
	}
	printk(KERN_ERR "Sound device %d went missing!\n", unit);
	return NULL;
}

/*
 *	This lock guards the sound loader list.
 */

static DEFINE_SPINLOCK(sound_loader_lock);

/*
 *	Allocate the controlling structure and add it to the sound driver
 *	list. Acquires locks as needed
 */

static int sound_insert_unit(struct sound_unit **list, const struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode, struct device *dev)
{
	struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL);
	int r;

	if (!s)
		return -ENOMEM;
		
	spin_lock(&sound_loader_lock);
	r = __sound_insert_unit(s, list, fops, index, low, top);
	spin_unlock(&sound_loader_lock);
	
	if (r < 0)
		goto fail;
	else if (r < SOUND_STEP)
		sprintf(s->name, "sound/%s", name);
	else
		sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);

	device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor),
		      s->name+6);
	return r;

 fail:
	kfree(s);
	return r;
}

/*
 *	Remove a unit. Acquires locks as needed. The drivers MUST have
 *	completed the removal before their file operations become
 *	invalid.
 */
 	
static void sound_remove_unit(struct sound_unit **list, int unit)
{
	struct sound_unit *p;

	spin_lock(&sound_loader_lock);
	p = __sound_remove_unit(list, unit);
	spin_unlock(&sound_loader_lock);
	if (p) {
		device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
		kfree(p);
	}
}

/*
 *	Allocations
 *
 *	0	*16		Mixers
 *	1	*8		Sequencers
 *	2	*16		Midi
 *	3	*16		DSP
 *	4	*16		SunDSP
 *	5	*16		DSP16
 *	6	--		sndstat (obsolete)
 *	7	*16		unused
 *	8	--		alternate sequencer (see above)
 *	9	*16		raw synthesizer access
 *	10	*16		unused
 *	11	*16		unused
 *	12	*16		unused
 *	13	*16		unused
 *	14	*16		unused
 *	15	*16		unused
 */

static struct sound_unit *chains[SOUND_STEP];

/**
 *	register_sound_special_device - register a special sound node
 *	@fops: File operations for the driver
 *	@unit: Unit number to allocate
 *      @dev: device pointer
 *
 *	Allocate a special sound device by minor number from the sound
 *	subsystem. The allocated number is returned on succes. On failure
 *	a negative error code is returned.
 */
 
int register_sound_special_device(const struct file_operations *fops, int unit,
				  struct device *dev)
{
	const int chain = unit % SOUND_STEP;
	int max_unit = 128 + chain;
	const char *name;
	char _name[16];

	switch (chain) {
	    case 0:
		name = "mixer";
		break;
	    case 1:
		name = "sequencer";
		if (unit >= SOUND_STEP)
			goto __unknown;
		max_unit = unit + 1;
		break;
	    case 2:
		name = "midi";
		break;
	    case 3:
		name = "dsp";
		break;
	    case 4:
		name = "audio";
		break;
	    case 8:
		name = "sequencer2";
		if (unit >= SOUND_STEP)
			goto __unknown;
		max_unit = unit + 1;
		break;
	    case 9:
		name = "dmmidi";
		break;
	    case 10:
		name = "dmfm";
		break;
	    case 12:
		name = "adsp";
		break;
	    case 13:
		name = "amidi";
		break;
	    case 14:
		name = "admmidi";
		break;
	    default:
	    	{
		    __unknown:
			sprintf(_name, "unknown%d", chain);
		    	if (unit >= SOUND_STEP)
		    		strcat(_name, "-");
		    	name = _name;
		}
		break;
	}
	return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit,
				 name, S_IRUSR | S_IWUSR, dev);
}
 
EXPORT_SYMBOL(register_sound_special_device);

int register_sound_special(const struct file_operations *fops, int unit)
{
	return register_sound_special_device(fops, unit, NULL);
}

EXPORT_SYMBOL(register_sound_special);

/**
 *	register_sound_mixer - register a mixer device
 *	@fops: File operations for the driver
 *	@dev: Unit number to allocate
 *
 *	Allocate a mixer device. Unit is the number of the mixer requested.
 *	Pass -1 to request the next free mixer unit. On success the allocated
 *	number is returned, on failure a negative error code is returned.
 */

int register_sound_mixer(const struct file_operations *fops, int dev)
{
	return sound_insert_unit(&chains[0], fops, dev, 0, 128,
				 "mixer", S_IRUSR | S_IWUSR, NULL);
}

EXPORT_SYMBOL(register_sound_mixer);

/**
 *	register_sound_midi - register a midi device
 *	@fops: File operations for the driver
 *	@dev: Unit number to allocate
 *
 *	Allocate a midi device. Unit is the number of the midi device requested.
 *	Pass -1 to request the next free midi unit. On success the allocated
 *	number is returned, on failure a negative error code is returned.
 */

int register_sound_midi(const struct file_operations *fops, int dev)
{
	return sound_insert_unit(&chains[2], fops, dev, 2, 130,
				 "midi", S_IRUSR | S_IWUSR, NULL);
}

EXPORT_SYMBOL(register_sound_midi);

/*
 *	DSP's are registered as a triple. Register only one and cheat
 *	in open - see below.
 */
 
/**
 *	register_sound_dsp - register a DSP device
 *	@fops: File operations for the driver
 *	@dev: Unit number to allocate
 *
 *	Allocate a DSP device. Unit is the number of the DSP requested.
 *	Pass -1 to request the next free DSP unit. On success the allocated
 *	number is returned, on failure a negative error code is returned.
 *
 *	This function allocates both the audio and dsp device entries together
 *	and will always allocate them as a matching pair - eg dsp3/audio3
 */

int register_sound_dsp(const struct file_operations *fops, int dev)
{
	return sound_insert_unit(&chains[3], fops, dev, 3, 131,
				 "dsp", S_IWUSR | S_IRUSR, NULL);
}

EXPORT_SYMBOL(register_sound_dsp);

/**
 *	unregister_sound_special - unregister a special sound device
 *	@unit: unit number to allocate
 *
 *	Release a sound device that was allocated with
 *	register_sound_special(). The unit passed is the return value from
 *	the register function.
 */


void unregister_sound_special(int unit)
{
	sound_remove_unit(&chains[unit % SOUND_STEP], unit);
}
 
EXPORT_SYMBOL(unregister_sound_special);

/**
 *	unregister_sound_mixer - unregister a mixer
 *	@unit: unit number to allocate
 *
 *	Release a sound device that was allocated with register_sound_mixer().
 *	The unit passed is the return value from the register function.
 */

void unregister_sound_mixer(int unit)
{
	sound_remove_unit(&chains[0], unit);
}

EXPORT_SYMBOL(unregister_sound_mixer);

/**
 *	unregister_sound_midi - unregister a midi device
 *	@unit: unit number to allocate
 *
 *	Release a sound device that was allocated with register_sound_midi().
 *	The unit passed is the return value from the register function.
 */

void unregister_sound_midi(int unit)
{
	return sound_remove_unit(&chains[2], unit);
}

EXPORT_SYMBOL(unregister_sound_midi);

/**
 *	unregister_sound_dsp - unregister a DSP device
 *	@unit: unit number to allocate
 *
 *	Release a sound device that was allocated with register_sound_dsp().
 *	The unit passed is the return value from the register function.
 *
 *	Both of the allocated units are released together automatically.
 */

void unregister_sound_dsp(int unit)
{
	return sound_remove_unit(&chains[3], unit);
}


EXPORT_SYMBOL(unregister_sound_dsp);

/*
 *	Now our file operations
 */

static int soundcore_open(struct inode *, struct file *);

static const struct file_operations soundcore_fops=
{
	/* We must have an owner or the module locking fails */
	.owner	= THIS_MODULE,
	.open	= soundcore_open,
};

static struct sound_unit *__look_for_unit(int chain, int unit)
{
	struct sound_unit *s;
	
	s=chains[chain];
	while(s && s->unit_minor <= unit)
	{
		if(s->unit_minor==unit)
			return s;
		s=s->next;
	}
	return NULL;
}

int soundcore_open(struct inode *inode, struct file *file)
{
	int chain;
	int unit = iminor(inode);
	struct sound_unit *s;
	const struct file_operations *new_fops = NULL;

	chain=unit&0x0F;
	if(chain==4 || chain==5)	/* dsp/audio/dsp16 */
	{
		unit&=0xF0;
		unit|=3;
		chain=3;
	}
	
	spin_lock(&sound_loader_lock);
	s = __look_for_unit(chain, unit);
	if (s)
		new_fops = fops_get(s->unit_fops);
	if (!new_fops) {
		spin_unlock(&sound_loader_lock);
		/*
		 *  Please, don't change this order or code.
		 *  For ALSA slot means soundcard and OSS emulation code
		 *  comes as add-on modules which aren't depend on
		 *  ALSA toplevel modules for soundcards, thus we need
		 *  load them at first.	  [Jaroslav Kysela <[email protected]>]
		 */
		request_module("sound-slot-%i", unit>>4);
		request_module("sound-service-%i-%i", unit>>4, chain);
		spin_lock(&sound_loader_lock);
		s = __look_for_unit(chain, unit);
		if (s)
			new_fops = fops_get(s->unit_fops);
	}
	if (new_fops) {
		/*
		 * We rely upon the fact that we can't be unloaded while the
		 * subdriver is there, so if ->open() is successful we can
		 * safely drop the reference counter and if it is not we can
		 * revert to old ->f_op. Ugly, indeed, but that's the cost of
		 * switching ->f_op in the first place.
		 */
		int err = 0;
		const struct file_operations *old_fops = file->f_op;
		file->f_op = new_fops;
		spin_unlock(&sound_loader_lock);
		if(file->f_op->open)
			err = file->f_op->open(inode,file);
		if (err) {
			fops_put(file->f_op);
			file->f_op = fops_get(old_fops);
		}
		fops_put(old_fops);
		return err;
	}
	spin_unlock(&sound_loader_lock);
	return -ENODEV;
}

MODULE_DESCRIPTION("Core sound module");
MODULE_AUTHOR("Alan Cox");
MODULE_LICENSE("GPL");
MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR);

static void __exit cleanup_soundcore(void)
{
	/* We have nothing to really do here - we know the lists must be
	   empty */
	unregister_chrdev(SOUND_MAJOR, "sound");
	class_destroy(sound_class);
}

static int __init init_soundcore(void)
{
	if (register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops)==-1) {
		printk(KERN_ERR "soundcore: sound device already in use.\n");
		return -EBUSY;
	}
	sound_class = class_create(THIS_MODULE, "sound");
	if (IS_ERR(sound_class))
		return PTR_ERR(sound_class);

	return 0;
}

module_init(init_soundcore);
module_exit(cleanup_soundcore);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Sound core handling. Breaks out sound functions to submodules
	3	*
	4	* Author: Alan Cox <[email protected]>
	5	*
	6	* Fixes:
	7	*
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License
	11	* as published by the Free Software Foundation; either version
	12	* 2 of the License, or (at your option) any later version.
	13	*
	14	* --------------------
	15	*
	16	* Top level handler for the sound subsystem. Various devices can
	17	* plug into this. The fact they don't all go via OSS doesn't mean
	18	* they don't have to implement the OSS API. There is a lot of logic
	19	* to keeping much of the OSS weight out of the code in a compatibility
	20	* module, but it's up to the driver to rember to load it...
	21	*
	22	* The code provides a set of functions for registration of devices
	23	* by type. This is done rather than providing a single call so that
	24	* we can hide any future changes in the internals (eg when we go to
	25	* 32bit dev_t) from the modules and their interface.
	26	*
	27	* Secondly we need to allocate the dsp, dsp16 and audio devices as
	28	* one. Thus we misuse the chains a bit to simplify this.
	29	*
	30	* Thirdly to make it more fun and for 2.3.x and above we do all
	31	* of this using fine grained locking.
	32	*
	33	* FIXME: we have to resolve modules and fine grained load/unload
	34	* locking at some point in 2.3.x.
	35	*/
	36
1da177e4 LT	37	#include <linux/module.h>
	38	#include <linux/init.h>
	39	#include <linux/slab.h>
	40	#include <linux/types.h>
	41	#include <linux/kernel.h>
	42	#include <linux/fs.h>
	43	#include <linux/sound.h>
	44	#include <linux/major.h>
	45	#include <linux/kmod.h>
1da177e4 LT	46	#include <linux/device.h>
	47
	48	#define SOUND_STEP 16
	49
	50
	51	struct sound_unit
	52	{
	53	int unit_minor;
99ac48f5	54	const struct file_operations *unit_fops;
1da177e4 LT	55	struct sound_unit *next;
	56	char name[32];
	57	};
	58
	59	#ifdef CONFIG_SOUND_MSNDCLAS
	60	extern int msnd_classic_init(void);
	61	#endif
	62	#ifdef CONFIG_SOUND_MSNDPIN
	63	extern int msnd_pinnacle_init(void);
	64	#endif
	65
619e666b	66	struct class *sound_class;
1da177e4 LT	67	EXPORT_SYMBOL(sound_class);
	68
	69	/*
	70	* Low level list operator. Scan the ordered list, find a hole and
	71	* join into it. Called with the lock asserted
	72	*/
	73
99ac48f5	74	static int __sound_insert_unit(struct sound_unit * s, struct sound_unit *list, const struct file_operations fops, int index, int low, int top)
1da177e4 LT	75	{
	76	int n=low;
	77
	78	if (index < 0) { /* first free */
	79
	80	while (list && (list)->unit_minor<n)
	81	list=&((*list)->next);
	82
	83	while(n<top)
	84	{
	85	/* Found a hole ? */
	86	if(list==NULL \|\| (list)->unit_minor>n)
	87	break;
	88	list=&((*list)->next);
	89	n+=SOUND_STEP;
	90	}
	91
	92	if(n>=top)
	93	return -ENOENT;
	94	} else {
	95	n = low+(index*16);
	96	while (*list) {
	97	if ((*list)->unit_minor==n)
	98	return -EBUSY;
	99	if ((*list)->unit_minor>n)
	100	break;
	101	list=&((*list)->next);
	102	}
	103	}
	104
	105	/*
	106	* Fill it in
	107	*/
	108
	109	s->unit_minor=n;
	110	s->unit_fops=fops;
	111
	112	/*
	113	* Link it
	114	*/
	115
	116	s->next=*list;
	117	*list=s;
	118
	119
	120	return n;
	121	}
	122
	123	/*
	124	* Remove a node from the chain. Called with the lock asserted
	125	*/
	126
	127	static struct sound_unit __sound_remove_unit(struct sound_unit *list, int unit)
	128	{
	129	while(*list)
	130	{
	131	struct sound_unit p=list;
	132	if(p->unit_minor==unit)
	133	{
	134	*list=p->next;
	135	return p;
	136	}
	137	list=&(p->next);
	138	}
139	printk(KERN_ERR "Sound device %d went missing!\n", unit);
140	return NULL;
141	}
142
143	/*
144	* This lock guards the sound loader list.
145	*/
146
147	static DEFINE_SPINLOCK(sound_loader_lock);
148
149	/*
150	* Allocate the controlling structure and add it to the sound driver
151	* list. Acquires locks as needed
152	*/
153
99ac48f5	154	static int sound_insert_unit(struct sound_unit *list, const struct file_operations fops, int index, int low, int top, const char name, umode_t mode, struct device dev)
1da177e4 LT	155	{
	156	struct sound_unit s = kmalloc(sizeof(s), GFP_KERNEL);
	157	int r;
	158
	159	if (!s)
	160	return -ENOMEM;
	161
	162	spin_lock(&sound_loader_lock);
	163	r = __sound_insert_unit(s, list, fops, index, low, top);
	164	spin_unlock(&sound_loader_lock);
	165
	166	if (r < 0)
	167	goto fail;
	168	else if (r < SOUND_STEP)
	169	sprintf(s->name, "sound/%s", name);
	170	else
	171	sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);
	172
d80f19fa GKH	173	device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor),
d80f19fa GKH	174	s->name+6);
1da177e4 LT	175	return r;
	176
	177	fail:
	178	kfree(s);
	179	return r;
	180	}
	181
	182	/*
	183	* Remove a unit. Acquires locks as needed. The drivers MUST have
	184	* completed the removal before their file operations become
	185	* invalid.
	186	*/
	187
	188	static void sound_remove_unit(struct sound_unit **list, int unit)
	189	{
	190	struct sound_unit *p;
	191
	192	spin_lock(&sound_loader_lock);
	193	p = __sound_remove_unit(list, unit);
	194	spin_unlock(&sound_loader_lock);
	195	if (p) {
d80f19fa	196	device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
1da177e4 LT	197	kfree(p);
	198	}
	199	}
	200
	201	/*
	202	* Allocations
	203	*
	204	* 0 *16 Mixers
	205	* 1 *8 Sequencers
	206	* 2 *16 Midi
	207	* 3 *16 DSP
	208	* 4 *16 SunDSP
	209	* 5 *16 DSP16
	210	* 6 -- sndstat (obsolete)
	211	* 7 *16 unused
	212	* 8 -- alternate sequencer (see above)
	213	* 9 *16 raw synthesizer access
	214	* 10 *16 unused
	215	* 11 *16 unused
	216	* 12 *16 unused
	217	* 13 *16 unused
	218	* 14 *16 unused
	219	* 15 *16 unused
	220	*/
	221
	222	static struct sound_unit *chains[SOUND_STEP];
	223
	224	/**
d568121c	225	* register_sound_special_device - register a special sound node
1da177e4 LT	226	* @fops: File operations for the driver
1da177e4 LT	227	* @unit: Unit number to allocate
d568121c	228	* @dev: device pointer
1da177e4 LT	229	*
	230	* Allocate a special sound device by minor number from the sound
	231	* subsystem. The allocated number is returned on succes. On failure
	232	* a negative error code is returned.
	233	*/
	234
99ac48f5	235	int register_sound_special_device(const struct file_operations *fops, int unit,
d568121c	236	struct device *dev)
1da177e4 LT	237	{
	238	const int chain = unit % SOUND_STEP;
	239	int max_unit = 128 + chain;
	240	const char *name;
	241	char _name[16];
	242
	243	switch (chain) {
	244	case 0:
	245	name = "mixer";
	246	break;
	247	case 1:
	248	name = "sequencer";
	249	if (unit >= SOUND_STEP)
	250	goto __unknown;
	251	max_unit = unit + 1;
	252	break;
	253	case 2:
	254	name = "midi";
	255	break;
	256	case 3:
	257	name = "dsp";
	258	break;
	259	case 4:
	260	name = "audio";
	261	break;
	262	case 8:
	263	name = "sequencer2";
	264	if (unit >= SOUND_STEP)
	265	goto __unknown;
	266	max_unit = unit + 1;
	267	break;
	268	case 9:
	269	name = "dmmidi";
	270	break;
	271	case 10:
	272	name = "dmfm";
	273	break;
	274	case 12:
	275	name = "adsp";
	276	break;
	277	case 13:
	278	name = "amidi";
	279	break;
	280	case 14:
	281	name = "admmidi";
	282	break;
	283	default:
	284	{
	285	__unknown:
	286	sprintf(_name, "unknown%d", chain);
	287	if (unit >= SOUND_STEP)
	288	strcat(_name, "-");
	289	name = _name;
	290	}
	291	break;
	292	}
	293	return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit,
d568121c	294	name, S_IRUSR \| S_IWUSR, dev);
1da177e4 LT	295	}
1da177e4 LT	296
d568121c TI	297	EXPORT_SYMBOL(register_sound_special_device);
d568121c TI	298
99ac48f5	299	int register_sound_special(const struct file_operations *fops, int unit)
d568121c TI	300	{
	301	return register_sound_special_device(fops, unit, NULL);
	302	}
	303
1da177e4 LT	304	EXPORT_SYMBOL(register_sound_special);
	305
	306	/**
	307	* register_sound_mixer - register a mixer device
	308	* @fops: File operations for the driver
	309	* @dev: Unit number to allocate
	310	*
	311	* Allocate a mixer device. Unit is the number of the mixer requested.
	312	* Pass -1 to request the next free mixer unit. On success the allocated
	313	* number is returned, on failure a negative error code is returned.
	314	*/
	315
99ac48f5	316	int register_sound_mixer(const struct file_operations *fops, int dev)
1da177e4 LT	317	{
1da177e4 LT	318	return sound_insert_unit(&chains[0], fops, dev, 0, 128,
d568121c	319	"mixer", S_IRUSR \| S_IWUSR, NULL);
1da177e4 LT	320	}
	321
	322	EXPORT_SYMBOL(register_sound_mixer);
	323
	324	/**
	325	* register_sound_midi - register a midi device
	326	* @fops: File operations for the driver
	327	* @dev: Unit number to allocate
	328	*
	329	* Allocate a midi device. Unit is the number of the midi device requested.
	330	* Pass -1 to request the next free midi unit. On success the allocated
	331	* number is returned, on failure a negative error code is returned.
	332	*/
	333
99ac48f5	334	int register_sound_midi(const struct file_operations *fops, int dev)
1da177e4 LT	335	{
1da177e4 LT	336	return sound_insert_unit(&chains[2], fops, dev, 2, 130,
d568121c	337	"midi", S_IRUSR \| S_IWUSR, NULL);
1da177e4 LT	338	}
	339
	340	EXPORT_SYMBOL(register_sound_midi);
	341
	342	/*
	343	* DSP's are registered as a triple. Register only one and cheat
	344	* in open - see below.
	345	*/
	346
	347	/**
	348	* register_sound_dsp - register a DSP device
	349	* @fops: File operations for the driver
	350	* @dev: Unit number to allocate
	351	*
	352	* Allocate a DSP device. Unit is the number of the DSP requested.
	353	* Pass -1 to request the next free DSP unit. On success the allocated
	354	* number is returned, on failure a negative error code is returned.
	355	*
	356	* This function allocates both the audio and dsp device entries together
	357	* and will always allocate them as a matching pair - eg dsp3/audio3
	358	*/
	359
99ac48f5	360	int register_sound_dsp(const struct file_operations *fops, int dev)
1da177e4 LT	361	{
1da177e4 LT	362	return sound_insert_unit(&chains[3], fops, dev, 3, 131,
d568121c	363	"dsp", S_IWUSR \| S_IRUSR, NULL);
1da177e4 LT	364	}
	365
	366	EXPORT_SYMBOL(register_sound_dsp);
	367
1da177e4 LT	368	/**
	369	* unregister_sound_special - unregister a special sound device
	370	* @unit: unit number to allocate
	371	*
	372	* Release a sound device that was allocated with
	373	* register_sound_special(). The unit passed is the return value from
	374	* the register function.
	375	*/
	376
	377
	378	void unregister_sound_special(int unit)
	379	{
	380	sound_remove_unit(&chains[unit % SOUND_STEP], unit);
	381	}
	382
	383	EXPORT_SYMBOL(unregister_sound_special);
	384
	385	/**
	386	* unregister_sound_mixer - unregister a mixer
	387	* @unit: unit number to allocate
	388	*
	389	* Release a sound device that was allocated with register_sound_mixer().
	390	* The unit passed is the return value from the register function.
	391	*/
	392
	393	void unregister_sound_mixer(int unit)
	394	{
	395	sound_remove_unit(&chains[0], unit);
	396	}
	397
	398	EXPORT_SYMBOL(unregister_sound_mixer);
	399
	400	/**
	401	* unregister_sound_midi - unregister a midi device
	402	* @unit: unit number to allocate
	403	*
	404	* Release a sound device that was allocated with register_sound_midi().
	405	* The unit passed is the return value from the register function.
	406	*/
	407
	408	void unregister_sound_midi(int unit)
	409	{
	410	return sound_remove_unit(&chains[2], unit);
	411	}
	412
	413	EXPORT_SYMBOL(unregister_sound_midi);
	414
	415	/**
	416	* unregister_sound_dsp - unregister a DSP device
	417	* @unit: unit number to allocate
	418	*
	419	* Release a sound device that was allocated with register_sound_dsp().
	420	* The unit passed is the return value from the register function.
	421	*
	422	* Both of the allocated units are released together automatically.
	423	*/
	424
	425	void unregister_sound_dsp(int unit)
	426	{
	427	return sound_remove_unit(&chains[3], unit);
	428	}
	429
	430
	431	EXPORT_SYMBOL(unregister_sound_dsp);
432
1da177e4 LT	433	/*
	434	* Now our file operations
	435	*/
	436
	437	static int soundcore_open(struct inode , struct file );
	438
9c2e08c5	439	static const struct file_operations soundcore_fops=
1da177e4 LT	440	{
	441	/* We must have an owner or the module locking fails */
	442	.owner = THIS_MODULE,
	443	.open = soundcore_open,
	444	};
	445
	446	static struct sound_unit *__look_for_unit(int chain, int unit)
	447	{
	448	struct sound_unit *s;
	449
	450	s=chains[chain];
	451	while(s && s->unit_minor <= unit)
	452	{
	453	if(s->unit_minor==unit)
	454	return s;
	455	s=s->next;
	456	}
	457	return NULL;
	458	}
	459
	460	int soundcore_open(struct inode inode, struct file file)
	461	{
	462	int chain;
	463	int unit = iminor(inode);
	464	struct sound_unit *s;
99ac48f5	465	const struct file_operations *new_fops = NULL;
1da177e4 LT	466
	467	chain=unit&0x0F;
	468	if(chain==4 \|\| chain==5) /* dsp/audio/dsp16 */
	469	{
	470	unit&=0xF0;
	471	unit\|=3;
	472	chain=3;
	473	}
	474
	475	spin_lock(&sound_loader_lock);
	476	s = __look_for_unit(chain, unit);
	477	if (s)
	478	new_fops = fops_get(s->unit_fops);
	479	if (!new_fops) {
	480	spin_unlock(&sound_loader_lock);
	481	/*
	482	* Please, don't change this order or code.
	483	* For ALSA slot means soundcard and OSS emulation code
	484	* comes as add-on modules which aren't depend on
	485	* ALSA toplevel modules for soundcards, thus we need
	486	* load them at first. [Jaroslav Kysela <[email protected]>]
	487	*/
	488	request_module("sound-slot-%i", unit>>4);
	489	request_module("sound-service-%i-%i", unit>>4, chain);
	490	spin_lock(&sound_loader_lock);
	491	s = __look_for_unit(chain, unit);
	492	if (s)
	493	new_fops = fops_get(s->unit_fops);
	494	}
	495	if (new_fops) {
	496	/*
	497	* We rely upon the fact that we can't be unloaded while the
	498	* subdriver is there, so if ->open() is successful we can
	499	* safely drop the reference counter and if it is not we can
	500	* revert to old ->f_op. Ugly, indeed, but that's the cost of
	501	* switching ->f_op in the first place.
	502	*/
	503	int err = 0;
99ac48f5	504	const struct file_operations *old_fops = file->f_op;
1da177e4 LT	505	file->f_op = new_fops;
	506	spin_unlock(&sound_loader_lock);
	507	if(file->f_op->open)
	508	err = file->f_op->open(inode,file);
	509	if (err) {
	510	fops_put(file->f_op);
	511	file->f_op = fops_get(old_fops);
	512	}
	513	fops_put(old_fops);
	514	return err;
	515	}
	516	spin_unlock(&sound_loader_lock);
	517	return -ENODEV;
	518	}
	519
1da177e4 LT	520	MODULE_DESCRIPTION("Core sound module");
	521	MODULE_AUTHOR("Alan Cox");
	522	MODULE_LICENSE("GPL");
	523	MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR);
	524
	525	static void __exit cleanup_soundcore(void)
	526	{
	527	/* We have nothing to really do here - we know the lists must be
	528	empty */
	529	unregister_chrdev(SOUND_MAJOR, "sound");
619e666b	530	class_destroy(sound_class);
1da177e4 LT	531	}
	532
	533	static int __init init_soundcore(void)
	534	{
	535	if (register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops)==-1) {
	536	printk(KERN_ERR "soundcore: sound device already in use.\n");
	537	return -EBUSY;
	538	}
619e666b	539	sound_class = class_create(THIS_MODULE, "sound");
1da177e4 LT	540	if (IS_ERR(sound_class))
	541	return PTR_ERR(sound_class);
	542
	543	return 0;
	544	}
	545
	546	module_init(init_soundcore);
	547	module_exit(cleanup_soundcore);