[linux-2.6-block.git] / sound / core / seq / seq_device.c

/*
 *  ALSA sequencer device management
 *  Copyright (c) 1999 by Takashi Iwai <tiwai@suse.de>
 *
 *   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.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *
 *----------------------------------------------------------------
 *
 * This device handler separates the card driver module from sequencer
 * stuff (sequencer core, synth drivers, etc), so that user can avoid
 * to spend unnecessary resources e.g. if he needs only listening to
 * MP3s.
 *
 * The card (or lowlevel) driver creates a sequencer device entry
 * via snd_seq_device_new().  This is an entry pointer to communicate
 * with the sequencer device "driver", which is involved with the
 * actual part to communicate with the sequencer core.
 * Each sequencer device entry has an id string and the corresponding
 * driver with the same id is loaded when required.  For example,
 * lowlevel codes to access emu8000 chip on sbawe card are included in
 * emu8000-synth module.  To activate this module, the hardware
 * resources like i/o port are passed via snd_seq_device argument.
 *
 */

#include <sound/driver.h>
#include <linux/init.h>
#include <sound/core.h>
#include <sound/info.h>
#include <sound/seq_device.h>
#include <sound/seq_kernel.h>
#include <sound/initval.h>
#include <linux/kmod.h>
#include <linux/slab.h>
#include <linux/mutex.h>

MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("ALSA sequencer device management");
MODULE_LICENSE("GPL");

/* driver state */
#define DRIVER_EMPTY		0
#define DRIVER_LOADED		(1<<0)
#define DRIVER_REQUESTED	(1<<1)
#define DRIVER_LOCKED		(1<<2)

struct ops_list {
	char id[ID_LEN];	/* driver id */
	int driver;		/* driver state */
	int used;		/* reference counter */
	int argsize;		/* argument size */

	/* operators */
	struct snd_seq_dev_ops ops;

	/* registred devices */
	struct list_head dev_list;	/* list of devices */
	int num_devices;	/* number of associated devices */
	int num_init_devices;	/* number of initialized devices */
	struct mutex reg_mutex;

	struct list_head list;	/* next driver */
};


static LIST_HEAD(opslist);
static int num_ops;
static DEFINE_MUTEX(ops_mutex);
#ifdef CONFIG_PROC_FS
static struct snd_info_entry *info_entry;
#endif

/*
 * prototypes
 */
static int snd_seq_device_free(struct snd_seq_device *dev);
static int snd_seq_device_dev_free(struct snd_device *device);
static int snd_seq_device_dev_register(struct snd_device *device);
static int snd_seq_device_dev_disconnect(struct snd_device *device);
static int snd_seq_device_dev_unregister(struct snd_device *device);

static int init_device(struct snd_seq_device *dev, struct ops_list *ops);
static int free_device(struct snd_seq_device *dev, struct ops_list *ops);
static struct ops_list *find_driver(char *id, int create_if_empty);
static struct ops_list *create_driver(char *id);
static void unlock_driver(struct ops_list *ops);
static void remove_drivers(void);

/*
 * show all drivers and their status
 */

#ifdef CONFIG_PROC_FS
static void snd_seq_device_info(struct snd_info_entry *entry,
				struct snd_info_buffer *buffer)
{
	struct list_head *head;

	mutex_lock(&ops_mutex);
	list_for_each(head, &opslist) {
		struct ops_list *ops = list_entry(head, struct ops_list, list);
		snd_iprintf(buffer, "snd-%s%s%s%s,%d\n",
				ops->id,
				ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""),
				ops->driver & DRIVER_REQUESTED ? ",requested" : "",
				ops->driver & DRIVER_LOCKED ? ",locked" : "",
				ops->num_devices);
	}
	mutex_unlock(&ops_mutex);
}
#endif
 
/*
 * load all registered drivers (called from seq_clientmgr.c)
 */

#ifdef CONFIG_KMOD
/* avoid auto-loading during module_init() */
static int snd_seq_in_init;
void snd_seq_autoload_lock(void)
{
	snd_seq_in_init++;
}

void snd_seq_autoload_unlock(void)
{
	snd_seq_in_init--;
}
#endif

void snd_seq_device_load_drivers(void)
{
#ifdef CONFIG_KMOD
	struct list_head *head;

	/* Calling request_module during module_init()
	 * may cause blocking.
	 */
	if (snd_seq_in_init)
		return;

	if (! current->fs->root)
		return;

	mutex_lock(&ops_mutex);
	list_for_each(head, &opslist) {
		struct ops_list *ops = list_entry(head, struct ops_list, list);
		if (! (ops->driver & DRIVER_LOADED) &&
		    ! (ops->driver & DRIVER_REQUESTED)) {
			ops->used++;
			mutex_unlock(&ops_mutex);
			ops->driver |= DRIVER_REQUESTED;
			request_module("snd-%s", ops->id);
			mutex_lock(&ops_mutex);
			ops->used--;
		}
	}
	mutex_unlock(&ops_mutex);
#endif
}

/*
 * register a sequencer device
 * card = card info (NULL allowed)
 * device = device number (if any)
 * id = id of driver
 * result = return pointer (NULL allowed if unnecessary)
 */
int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
		       struct snd_seq_device **result)
{
	struct snd_seq_device *dev;
	struct ops_list *ops;
	int err;
	static struct snd_device_ops dops = {
		.dev_free = snd_seq_device_dev_free,
		.dev_register = snd_seq_device_dev_register,
		.dev_disconnect = snd_seq_device_dev_disconnect,
		.dev_unregister = snd_seq_device_dev_unregister
	};

	if (result)
		*result = NULL;

	snd_assert(id != NULL, return -EINVAL);

	ops = find_driver(id, 1);
	if (ops == NULL)
		return -ENOMEM;

	dev = kzalloc(sizeof(*dev)*2 + argsize, GFP_KERNEL);
	if (dev == NULL) {
		unlock_driver(ops);
		return -ENOMEM;
	}

	/* set up device info */
	dev->card = card;
	dev->device = device;
	strlcpy(dev->id, id, sizeof(dev->id));
	dev->argsize = argsize;
	dev->status = SNDRV_SEQ_DEVICE_FREE;

	/* add this device to the list */
	mutex_lock(&ops->reg_mutex);
	list_add_tail(&dev->list, &ops->dev_list);
	ops->num_devices++;
	mutex_unlock(&ops->reg_mutex);

	unlock_driver(ops);
	
	if ((err = snd_device_new(card, SNDRV_DEV_SEQUENCER, dev, &dops)) < 0) {
		snd_seq_device_free(dev);
		return err;
	}
	
	if (result)
		*result = dev;

	return 0;
}

/*
 * free the existing device
 */
static int snd_seq_device_free(struct snd_seq_device *dev)
{
	struct ops_list *ops;

	snd_assert(dev != NULL, return -EINVAL);

	ops = find_driver(dev->id, 0);
	if (ops == NULL)
		return -ENXIO;

	/* remove the device from the list */
	mutex_lock(&ops->reg_mutex);
	list_del(&dev->list);
	ops->num_devices--;
	mutex_unlock(&ops->reg_mutex);

	free_device(dev, ops);
	if (dev->private_free)
		dev->private_free(dev);
	kfree(dev);

	unlock_driver(ops);

	return 0;
}

static int snd_seq_device_dev_free(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;
	return snd_seq_device_free(dev);
}

/*
 * register the device
 */
static int snd_seq_device_dev_register(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;
	struct ops_list *ops;

	ops = find_driver(dev->id, 0);
	if (ops == NULL)
		return -ENOENT;

	/* initialize this device if the corresponding driver was
	 * already loaded
	 */
	if (ops->driver & DRIVER_LOADED)
		init_device(dev, ops);

	unlock_driver(ops);
	return 0;
}

/*
 * disconnect the device
 */
static int snd_seq_device_dev_disconnect(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;
	struct ops_list *ops;

	ops = find_driver(dev->id, 0);
	if (ops == NULL)
		return -ENOENT;

	free_device(dev, ops);

	unlock_driver(ops);
	return 0;
}

/*
 * unregister the existing device
 */
static int snd_seq_device_dev_unregister(struct snd_device *device)
{
	struct snd_seq_device *dev = device->device_data;
	return snd_seq_device_free(dev);
}

/*
 * register device driver
 * id = driver id
 * entry = driver operators - duplicated to each instance
 */
int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
				   int argsize)
{
	struct list_head *head;
	struct ops_list *ops;

	if (id == NULL || entry == NULL ||
	    entry->init_device == NULL || entry->free_device == NULL)
		return -EINVAL;

	snd_seq_autoload_lock();
	ops = find_driver(id, 1);
	if (ops == NULL) {
		snd_seq_autoload_unlock();
		return -ENOMEM;
	}
	if (ops->driver & DRIVER_LOADED) {
		snd_printk(KERN_WARNING "driver_register: driver '%s' already exists\n", id);
		unlock_driver(ops);
		snd_seq_autoload_unlock();
		return -EBUSY;
	}

	mutex_lock(&ops->reg_mutex);
	/* copy driver operators */
	ops->ops = *entry;
	ops->driver |= DRIVER_LOADED;
	ops->argsize = argsize;

	/* initialize existing devices if necessary */
	list_for_each(head, &ops->dev_list) {
		struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
		init_device(dev, ops);
	}
	mutex_unlock(&ops->reg_mutex);

	unlock_driver(ops);
	snd_seq_autoload_unlock();

	return 0;
}


/*
 * create driver record
 */
static struct ops_list * create_driver(char *id)
{
	struct ops_list *ops;

	ops = kmalloc(sizeof(*ops), GFP_KERNEL);
	if (ops == NULL)
		return ops;
	memset(ops, 0, sizeof(*ops));

	/* set up driver entry */
	strlcpy(ops->id, id, sizeof(ops->id));
	mutex_init(&ops->reg_mutex);
	ops->driver = DRIVER_EMPTY;
	INIT_LIST_HEAD(&ops->dev_list);
	/* lock this instance */
	ops->used = 1;

	/* register driver entry */
	mutex_lock(&ops_mutex);
	list_add_tail(&ops->list, &opslist);
	num_ops++;
	mutex_unlock(&ops_mutex);

	return ops;
}


/*
 * unregister the specified driver
 */
int snd_seq_device_unregister_driver(char *id)
{
	struct list_head *head;
	struct ops_list *ops;

	ops = find_driver(id, 0);
	if (ops == NULL)
		return -ENXIO;
	if (! (ops->driver & DRIVER_LOADED) ||
	    (ops->driver & DRIVER_LOCKED)) {
		snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n",
			   id, ops->driver);
		unlock_driver(ops);
		return -EBUSY;
	}

	/* close and release all devices associated with this driver */
	mutex_lock(&ops->reg_mutex);
	ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */
	list_for_each(head, &ops->dev_list) {
		struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
		free_device(dev, ops);
	}

	ops->driver = 0;
	if (ops->num_init_devices > 0)
		snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
			   ops->num_init_devices);
	mutex_unlock(&ops->reg_mutex);

	unlock_driver(ops);

	/* remove empty driver entries */
	remove_drivers();

	return 0;
}


/*
 * remove empty driver entries
 */
static void remove_drivers(void)
{
	struct list_head *head;

	mutex_lock(&ops_mutex);
	head = opslist.next;
	while (head != &opslist) {
		struct ops_list *ops = list_entry(head, struct ops_list, list);
		if (! (ops->driver & DRIVER_LOADED) &&
		    ops->used == 0 && ops->num_devices == 0) {
			head = head->next;
			list_del(&ops->list);
			kfree(ops);
			num_ops--;
		} else
			head = head->next;
	}
	mutex_unlock(&ops_mutex);
}

/*
 * initialize the device - call init_device operator
 */
static int init_device(struct snd_seq_device *dev, struct ops_list *ops)
{
	if (! (ops->driver & DRIVER_LOADED))
		return 0; /* driver is not loaded yet */
	if (dev->status != SNDRV_SEQ_DEVICE_FREE)
		return 0; /* already initialized */
	if (ops->argsize != dev->argsize) {
		snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
			   dev->name, ops->id, ops->argsize, dev->argsize);
		return -EINVAL;
	}
	if (ops->ops.init_device(dev) >= 0) {
		dev->status = SNDRV_SEQ_DEVICE_REGISTERED;
		ops->num_init_devices++;
	} else {
		snd_printk(KERN_ERR "init_device failed: %s: %s\n",
			   dev->name, dev->id);
	}

	return 0;
}

/*
 * release the device - call free_device operator
 */
static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
{
	int result;

	if (! (ops->driver & DRIVER_LOADED))
		return 0; /* driver is not loaded yet */
	if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED)
		return 0; /* not registered */
	if (ops->argsize != dev->argsize) {
		snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
			   dev->name, ops->id, ops->argsize, dev->argsize);
		return -EINVAL;
	}
	if ((result = ops->ops.free_device(dev)) >= 0 || result == -ENXIO) {
		dev->status = SNDRV_SEQ_DEVICE_FREE;
		dev->driver_data = NULL;
		ops->num_init_devices--;
	} else {
		snd_printk(KERN_ERR "free_device failed: %s: %s\n",
			   dev->name, dev->id);
	}

	return 0;
}

/*
 * find the matching driver with given id
 */
static struct ops_list * find_driver(char *id, int create_if_empty)
{
	struct list_head *head;

	mutex_lock(&ops_mutex);
	list_for_each(head, &opslist) {
		struct ops_list *ops = list_entry(head, struct ops_list, list);
		if (strcmp(ops->id, id) == 0) {
			ops->used++;
			mutex_unlock(&ops_mutex);
			return ops;
		}
	}
	mutex_unlock(&ops_mutex);
	if (create_if_empty)
		return create_driver(id);
	return NULL;
}

static void unlock_driver(struct ops_list *ops)
{
	mutex_lock(&ops_mutex);
	ops->used--;
	mutex_unlock(&ops_mutex);
}


/*
 * module part
 */

static int __init alsa_seq_device_init(void)
{
#ifdef CONFIG_PROC_FS
	info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers",
						  snd_seq_root);
	if (info_entry == NULL)
		return -ENOMEM;
	info_entry->content = SNDRV_INFO_CONTENT_TEXT;
	info_entry->c.text.read = snd_seq_device_info;
	if (snd_info_register(info_entry) < 0) {
		snd_info_free_entry(info_entry);
		return -ENOMEM;
	}
#endif
	return 0;
}

static void __exit alsa_seq_device_exit(void)
{
	remove_drivers();
#ifdef CONFIG_PROC_FS
	snd_info_unregister(info_entry);
#endif
	if (num_ops)
		snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops);
}

module_init(alsa_seq_device_init)
module_exit(alsa_seq_device_exit)

EXPORT_SYMBOL(snd_seq_device_load_drivers);
EXPORT_SYMBOL(snd_seq_device_new);
EXPORT_SYMBOL(snd_seq_device_register_driver);
EXPORT_SYMBOL(snd_seq_device_unregister_driver);
#ifdef CONFIG_KMOD
EXPORT_SYMBOL(snd_seq_autoload_lock);
EXPORT_SYMBOL(snd_seq_autoload_unlock);
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ALSA sequencer device management
	3	* Copyright (c) 1999 by Takashi Iwai <tiwai@suse.de>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*
	19	*
	20	*----------------------------------------------------------------
	21	*
	22	* This device handler separates the card driver module from sequencer
	23	* stuff (sequencer core, synth drivers, etc), so that user can avoid
	24	* to spend unnecessary resources e.g. if he needs only listening to
	25	* MP3s.
	26	*
	27	* The card (or lowlevel) driver creates a sequencer device entry
	28	* via snd_seq_device_new(). This is an entry pointer to communicate
	29	* with the sequencer device "driver", which is involved with the
	30	* actual part to communicate with the sequencer core.
	31	* Each sequencer device entry has an id string and the corresponding
	32	* driver with the same id is loaded when required. For example,
	33	* lowlevel codes to access emu8000 chip on sbawe card are included in
	34	* emu8000-synth module. To activate this module, the hardware
	35	* resources like i/o port are passed via snd_seq_device argument.
	36	*
	37	*/
	38
	39	#include <sound/driver.h>
	40	#include <linux/init.h>
	41	#include <sound/core.h>
	42	#include <sound/info.h>
	43	#include <sound/seq_device.h>
	44	#include <sound/seq_kernel.h>
	45	#include <sound/initval.h>
	46	#include <linux/kmod.h>
	47	#include <linux/slab.h>
1a60d4c5	48	#include <linux/mutex.h>
1da177e4 LT	49
	50	MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
	51	MODULE_DESCRIPTION("ALSA sequencer device management");
	52	MODULE_LICENSE("GPL");
	53
1da177e4 LT	54	/* driver state */
	55	#define DRIVER_EMPTY 0
	56	#define DRIVER_LOADED (1<<0)
	57	#define DRIVER_REQUESTED (1<<1)
	58	#define DRIVER_LOCKED (1<<2)
	59
	60	struct ops_list {
	61	char id[ID_LEN]; /* driver id */
	62	int driver; /* driver state */
	63	int used; /* reference counter */
	64	int argsize; /* argument size */
	65
	66	/* operators */
c7e0b5bf	67	struct snd_seq_dev_ops ops;
1da177e4 LT	68
	69	/* registred devices */
	70	struct list_head dev_list; /* list of devices */
	71	int num_devices; /* number of associated devices */
	72	int num_init_devices; /* number of initialized devices */
1a60d4c5	73	struct mutex reg_mutex;
1da177e4 LT	74
	75	struct list_head list; /* next driver */
	76	};
	77
	78
	79	static LIST_HEAD(opslist);
	80	static int num_ops;
1a60d4c5	81	static DEFINE_MUTEX(ops_mutex);
04f141a8	82	#ifdef CONFIG_PROC_FS
6581f4e7	83	static struct snd_info_entry *info_entry;
04f141a8	84	#endif
1da177e4 LT	85
	86	/*
	87	* prototypes
	88	*/
c7e0b5bf TI	89	static int snd_seq_device_free(struct snd_seq_device *dev);
	90	static int snd_seq_device_dev_free(struct snd_device *device);
	91	static int snd_seq_device_dev_register(struct snd_device *device);
	92	static int snd_seq_device_dev_disconnect(struct snd_device *device);
	93	static int snd_seq_device_dev_unregister(struct snd_device *device);
	94
	95	static int init_device(struct snd_seq_device dev, struct ops_list ops);
	96	static int free_device(struct snd_seq_device dev, struct ops_list ops);
	97	static struct ops_list find_driver(char id, int create_if_empty);
	98	static struct ops_list create_driver(char id);
	99	static void unlock_driver(struct ops_list *ops);
1da177e4 LT	100	static void remove_drivers(void);
	101
	102	/*
	103	* show all drivers and their status
	104	*/
	105
04f141a8	106	#ifdef CONFIG_PROC_FS
c7e0b5bf TI	107	static void snd_seq_device_info(struct snd_info_entry *entry,
c7e0b5bf TI	108	struct snd_info_buffer *buffer)
1da177e4 LT	109	{
	110	struct list_head *head;
	111
1a60d4c5	112	mutex_lock(&ops_mutex);
1da177e4	113	list_for_each(head, &opslist) {
c7e0b5bf	114	struct ops_list *ops = list_entry(head, struct ops_list, list);
1da177e4 LT	115	snd_iprintf(buffer, "snd-%s%s%s%s,%d\n",
	116	ops->id,
	117	ops->driver & DRIVER_LOADED ? ",loaded" : (ops->driver == DRIVER_EMPTY ? ",empty" : ""),
	118	ops->driver & DRIVER_REQUESTED ? ",requested" : "",
	119	ops->driver & DRIVER_LOCKED ? ",locked" : "",
	120	ops->num_devices);
	121	}
1a60d4c5	122	mutex_unlock(&ops_mutex);
1da177e4	123	}
04f141a8	124	#endif
1da177e4 LT	125
	126	/*
	127	* load all registered drivers (called from seq_clientmgr.c)
	128	*/
	129
	130	#ifdef CONFIG_KMOD
	131	/* avoid auto-loading during module_init() */
	132	static int snd_seq_in_init;
	133	void snd_seq_autoload_lock(void)
	134	{
	135	snd_seq_in_init++;
	136	}
	137
	138	void snd_seq_autoload_unlock(void)
	139	{
	140	snd_seq_in_init--;
	141	}
	142	#endif
	143
	144	void snd_seq_device_load_drivers(void)
	145	{
	146	#ifdef CONFIG_KMOD
	147	struct list_head *head;
	148
	149	/* Calling request_module during module_init()
	150	* may cause blocking.
	151	*/
	152	if (snd_seq_in_init)
	153	return;
	154
	155	if (! current->fs->root)
	156	return;
	157
1a60d4c5	158	mutex_lock(&ops_mutex);
1da177e4	159	list_for_each(head, &opslist) {
c7e0b5bf	160	struct ops_list *ops = list_entry(head, struct ops_list, list);
1da177e4 LT	161	if (! (ops->driver & DRIVER_LOADED) &&
	162	! (ops->driver & DRIVER_REQUESTED)) {
	163	ops->used++;
1a60d4c5	164	mutex_unlock(&ops_mutex);
1da177e4 LT	165	ops->driver \|= DRIVER_REQUESTED;
1da177e4 LT	166	request_module("snd-%s", ops->id);
1a60d4c5	167	mutex_lock(&ops_mutex);
1da177e4 LT	168	ops->used--;
	169	}
	170	}
1a60d4c5	171	mutex_unlock(&ops_mutex);
1da177e4 LT	172	#endif
	173	}
	174
	175	/*
	176	* register a sequencer device
	177	* card = card info (NULL allowed)
	178	* device = device number (if any)
	179	* id = id of driver
	180	* result = return pointer (NULL allowed if unnecessary)
	181	*/
c7e0b5bf TI	182	int snd_seq_device_new(struct snd_card card, int device, char id, int argsize,
c7e0b5bf TI	183	struct snd_seq_device **result)
1da177e4	184	{
c7e0b5bf TI	185	struct snd_seq_device *dev;
c7e0b5bf TI	186	struct ops_list *ops;
1da177e4	187	int err;
c7e0b5bf	188	static struct snd_device_ops dops = {
1da177e4 LT	189	.dev_free = snd_seq_device_dev_free,
	190	.dev_register = snd_seq_device_dev_register,
	191	.dev_disconnect = snd_seq_device_dev_disconnect,
	192	.dev_unregister = snd_seq_device_dev_unregister
	193	};
	194
	195	if (result)
	196	*result = NULL;
	197
	198	snd_assert(id != NULL, return -EINVAL);
	199
	200	ops = find_driver(id, 1);
	201	if (ops == NULL)
	202	return -ENOMEM;
	203
ecca82b4	204	dev = kzalloc(sizeof(dev)2 + argsize, GFP_KERNEL);
1da177e4 LT	205	if (dev == NULL) {
	206	unlock_driver(ops);
	207	return -ENOMEM;
	208	}
	209
	210	/* set up device info */
	211	dev->card = card;
	212	dev->device = device;
	213	strlcpy(dev->id, id, sizeof(dev->id));
	214	dev->argsize = argsize;
	215	dev->status = SNDRV_SEQ_DEVICE_FREE;
	216
	217	/* add this device to the list */
1a60d4c5	218	mutex_lock(&ops->reg_mutex);
1da177e4 LT	219	list_add_tail(&dev->list, &ops->dev_list);
1da177e4 LT	220	ops->num_devices++;
1a60d4c5	221	mutex_unlock(&ops->reg_mutex);
1da177e4 LT	222
	223	unlock_driver(ops);
	224
	225	if ((err = snd_device_new(card, SNDRV_DEV_SEQUENCER, dev, &dops)) < 0) {
	226	snd_seq_device_free(dev);
	227	return err;
	228	}
	229
	230	if (result)
	231	*result = dev;
	232
	233	return 0;
	234	}
	235
	236	/*
	237	* free the existing device
	238	*/
c7e0b5bf	239	static int snd_seq_device_free(struct snd_seq_device *dev)
1da177e4	240	{
c7e0b5bf	241	struct ops_list *ops;
1da177e4 LT	242
	243	snd_assert(dev != NULL, return -EINVAL);
	244
	245	ops = find_driver(dev->id, 0);
	246	if (ops == NULL)
	247	return -ENXIO;
	248
	249	/* remove the device from the list */
1a60d4c5	250	mutex_lock(&ops->reg_mutex);
1da177e4 LT	251	list_del(&dev->list);
1da177e4 LT	252	ops->num_devices--;
1a60d4c5	253	mutex_unlock(&ops->reg_mutex);
1da177e4 LT	254
	255	free_device(dev, ops);
	256	if (dev->private_free)
	257	dev->private_free(dev);
	258	kfree(dev);
	259
	260	unlock_driver(ops);
	261
	262	return 0;
	263	}
	264
c7e0b5bf	265	static int snd_seq_device_dev_free(struct snd_device *device)
1da177e4	266	{
c7e0b5bf	267	struct snd_seq_device *dev = device->device_data;
1da177e4 LT	268	return snd_seq_device_free(dev);
	269	}
	270
	271	/*
	272	* register the device
	273	*/
c7e0b5bf	274	static int snd_seq_device_dev_register(struct snd_device *device)
1da177e4	275	{
c7e0b5bf TI	276	struct snd_seq_device *dev = device->device_data;
c7e0b5bf TI	277	struct ops_list *ops;
1da177e4 LT	278
	279	ops = find_driver(dev->id, 0);
	280	if (ops == NULL)
	281	return -ENOENT;
	282
	283	/* initialize this device if the corresponding driver was
	284	* already loaded
	285	*/
	286	if (ops->driver & DRIVER_LOADED)
	287	init_device(dev, ops);
	288
	289	unlock_driver(ops);
	290	return 0;
	291	}
	292
	293	/*
	294	* disconnect the device
	295	*/
c7e0b5bf	296	static int snd_seq_device_dev_disconnect(struct snd_device *device)
1da177e4	297	{
c7e0b5bf TI	298	struct snd_seq_device *dev = device->device_data;
c7e0b5bf TI	299	struct ops_list *ops;
1da177e4 LT	300
	301	ops = find_driver(dev->id, 0);
	302	if (ops == NULL)
	303	return -ENOENT;
	304
	305	free_device(dev, ops);
	306
	307	unlock_driver(ops);
	308	return 0;
	309	}
	310
	311	/*
	312	* unregister the existing device
	313	*/
c7e0b5bf	314	static int snd_seq_device_dev_unregister(struct snd_device *device)
1da177e4	315	{
c7e0b5bf	316	struct snd_seq_device *dev = device->device_data;
1da177e4 LT	317	return snd_seq_device_free(dev);
	318	}
	319
	320	/*
	321	* register device driver
	322	* id = driver id
	323	* entry = driver operators - duplicated to each instance
	324	*/
c7e0b5bf TI	325	int snd_seq_device_register_driver(char id, struct snd_seq_dev_ops entry,
c7e0b5bf TI	326	int argsize)
1da177e4 LT	327	{
1da177e4 LT	328	struct list_head *head;
c7e0b5bf	329	struct ops_list *ops;
1da177e4 LT	330
	331	if (id == NULL \|\| entry == NULL \|\|
	332	entry->init_device == NULL \|\| entry->free_device == NULL)
	333	return -EINVAL;
	334
	335	snd_seq_autoload_lock();
	336	ops = find_driver(id, 1);
	337	if (ops == NULL) {
	338	snd_seq_autoload_unlock();
	339	return -ENOMEM;
	340	}
	341	if (ops->driver & DRIVER_LOADED) {
	342	snd_printk(KERN_WARNING "driver_register: driver '%s' already exists\n", id);
	343	unlock_driver(ops);
	344	snd_seq_autoload_unlock();
	345	return -EBUSY;
	346	}
	347
1a60d4c5	348	mutex_lock(&ops->reg_mutex);
1da177e4 LT	349	/* copy driver operators */
	350	ops->ops = *entry;
	351	ops->driver \|= DRIVER_LOADED;
	352	ops->argsize = argsize;
	353
	354	/* initialize existing devices if necessary */
	355	list_for_each(head, &ops->dev_list) {
c7e0b5bf	356	struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
1da177e4 LT	357	init_device(dev, ops);
1da177e4 LT	358	}
1a60d4c5	359	mutex_unlock(&ops->reg_mutex);
1da177e4 LT	360
	361	unlock_driver(ops);
	362	snd_seq_autoload_unlock();
	363
	364	return 0;
	365	}
	366
	367
	368	/*
	369	* create driver record
	370	*/
c7e0b5bf	371	static struct ops_list * create_driver(char *id)
1da177e4	372	{
c7e0b5bf	373	struct ops_list *ops;
1da177e4 LT	374
	375	ops = kmalloc(sizeof(*ops), GFP_KERNEL);
	376	if (ops == NULL)
	377	return ops;
	378	memset(ops, 0, sizeof(*ops));
	379
	380	/* set up driver entry */
	381	strlcpy(ops->id, id, sizeof(ops->id));
1a60d4c5	382	mutex_init(&ops->reg_mutex);
1da177e4 LT	383	ops->driver = DRIVER_EMPTY;
	384	INIT_LIST_HEAD(&ops->dev_list);
	385	/* lock this instance */
	386	ops->used = 1;
	387
	388	/* register driver entry */
1a60d4c5	389	mutex_lock(&ops_mutex);
1da177e4 LT	390	list_add_tail(&ops->list, &opslist);
1da177e4 LT	391	num_ops++;
1a60d4c5	392	mutex_unlock(&ops_mutex);
1da177e4 LT	393
	394	return ops;
	395	}
	396
	397
	398	/*
	399	* unregister the specified driver
	400	*/
	401	int snd_seq_device_unregister_driver(char *id)
	402	{
	403	struct list_head *head;
c7e0b5bf	404	struct ops_list *ops;
1da177e4 LT	405
	406	ops = find_driver(id, 0);
	407	if (ops == NULL)
	408	return -ENXIO;
	409	if (! (ops->driver & DRIVER_LOADED) \|\|
	410	(ops->driver & DRIVER_LOCKED)) {
c7e0b5bf TI	411	snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n",
c7e0b5bf TI	412	id, ops->driver);
1da177e4 LT	413	unlock_driver(ops);
	414	return -EBUSY;
	415	}
	416
	417	/* close and release all devices associated with this driver */
1a60d4c5	418	mutex_lock(&ops->reg_mutex);
1da177e4 LT	419	ops->driver \|= DRIVER_LOCKED; /* do not remove this driver recursively */
1da177e4 LT	420	list_for_each(head, &ops->dev_list) {
c7e0b5bf	421	struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
1da177e4 LT	422	free_device(dev, ops);
	423	}
	424
	425	ops->driver = 0;
	426	if (ops->num_init_devices > 0)
c7e0b5bf TI	427	snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
c7e0b5bf TI	428	ops->num_init_devices);
1a60d4c5	429	mutex_unlock(&ops->reg_mutex);
1da177e4 LT	430
	431	unlock_driver(ops);
	432
	433	/* remove empty driver entries */
	434	remove_drivers();
	435
	436	return 0;
	437	}
	438
	439
	440	/*
	441	* remove empty driver entries
	442	*/
	443	static void remove_drivers(void)
	444	{
	445	struct list_head *head;
	446
1a60d4c5	447	mutex_lock(&ops_mutex);
1da177e4 LT	448	head = opslist.next;
1da177e4 LT	449	while (head != &opslist) {
c7e0b5bf	450	struct ops_list *ops = list_entry(head, struct ops_list, list);
1da177e4 LT	451	if (! (ops->driver & DRIVER_LOADED) &&
	452	ops->used == 0 && ops->num_devices == 0) {
	453	head = head->next;
	454	list_del(&ops->list);
	455	kfree(ops);
	456	num_ops--;
	457	} else
	458	head = head->next;
	459	}
1a60d4c5	460	mutex_unlock(&ops_mutex);
1da177e4 LT	461	}
	462
	463	/*
	464	* initialize the device - call init_device operator
	465	*/
c7e0b5bf	466	static int init_device(struct snd_seq_device dev, struct ops_list ops)
1da177e4 LT	467	{
	468	if (! (ops->driver & DRIVER_LOADED))
	469	return 0; /* driver is not loaded yet */
	470	if (dev->status != SNDRV_SEQ_DEVICE_FREE)
	471	return 0; /* already initialized */
	472	if (ops->argsize != dev->argsize) {
c7e0b5bf TI	473	snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
c7e0b5bf TI	474	dev->name, ops->id, ops->argsize, dev->argsize);
1da177e4 LT	475	return -EINVAL;
	476	}
	477	if (ops->ops.init_device(dev) >= 0) {
	478	dev->status = SNDRV_SEQ_DEVICE_REGISTERED;
	479	ops->num_init_devices++;
	480	} else {
c7e0b5bf TI	481	snd_printk(KERN_ERR "init_device failed: %s: %s\n",
c7e0b5bf TI	482	dev->name, dev->id);
1da177e4 LT	483	}
	484
	485	return 0;
	486	}
	487
	488	/*
	489	* release the device - call free_device operator
	490	*/
c7e0b5bf	491	static int free_device(struct snd_seq_device dev, struct ops_list ops)
1da177e4 LT	492	{
	493	int result;
	494
	495	if (! (ops->driver & DRIVER_LOADED))
	496	return 0; /* driver is not loaded yet */
	497	if (dev->status != SNDRV_SEQ_DEVICE_REGISTERED)
	498	return 0; /* not registered */
	499	if (ops->argsize != dev->argsize) {
c7e0b5bf TI	500	snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
c7e0b5bf TI	501	dev->name, ops->id, ops->argsize, dev->argsize);
1da177e4 LT	502	return -EINVAL;
	503	}
	504	if ((result = ops->ops.free_device(dev)) >= 0 \|\| result == -ENXIO) {
	505	dev->status = SNDRV_SEQ_DEVICE_FREE;
	506	dev->driver_data = NULL;
	507	ops->num_init_devices--;
	508	} else {
c7e0b5bf TI	509	snd_printk(KERN_ERR "free_device failed: %s: %s\n",
c7e0b5bf TI	510	dev->name, dev->id);
1da177e4 LT	511	}
	512
	513	return 0;
	514	}
	515
	516	/*
	517	* find the matching driver with given id
	518	*/
c7e0b5bf	519	static struct ops_list * find_driver(char *id, int create_if_empty)
1da177e4 LT	520	{
	521	struct list_head *head;
	522
1a60d4c5	523	mutex_lock(&ops_mutex);
1da177e4	524	list_for_each(head, &opslist) {
c7e0b5bf	525	struct ops_list *ops = list_entry(head, struct ops_list, list);
1da177e4 LT	526	if (strcmp(ops->id, id) == 0) {
1da177e4 LT	527	ops->used++;
1a60d4c5	528	mutex_unlock(&ops_mutex);
1da177e4 LT	529	return ops;
	530	}
	531	}
1a60d4c5	532	mutex_unlock(&ops_mutex);
1da177e4 LT	533	if (create_if_empty)
	534	return create_driver(id);
	535	return NULL;
	536	}
	537
c7e0b5bf	538	static void unlock_driver(struct ops_list *ops)
1da177e4	539	{
1a60d4c5	540	mutex_lock(&ops_mutex);
1da177e4	541	ops->used--;
1a60d4c5	542	mutex_unlock(&ops_mutex);
1da177e4 LT	543	}
	544
	545
	546	/*
	547	* module part
	548	*/
	549
	550	static int __init alsa_seq_device_init(void)
	551	{
04f141a8	552	#ifdef CONFIG_PROC_FS
c7e0b5bf TI	553	info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers",
c7e0b5bf TI	554	snd_seq_root);
1da177e4 LT	555	if (info_entry == NULL)
	556	return -ENOMEM;
	557	info_entry->content = SNDRV_INFO_CONTENT_TEXT;
1da177e4 LT	558	info_entry->c.text.read = snd_seq_device_info;
	559	if (snd_info_register(info_entry) < 0) {
	560	snd_info_free_entry(info_entry);
	561	return -ENOMEM;
	562	}
04f141a8	563	#endif
1da177e4 LT	564	return 0;
	565	}
	566
	567	static void __exit alsa_seq_device_exit(void)
	568	{
	569	remove_drivers();
04f141a8	570	#ifdef CONFIG_PROC_FS
1da177e4	571	snd_info_unregister(info_entry);
04f141a8	572	#endif
1da177e4 LT	573	if (num_ops)
	574	snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops);
	575	}
	576
	577	module_init(alsa_seq_device_init)
	578	module_exit(alsa_seq_device_exit)
	579
	580	EXPORT_SYMBOL(snd_seq_device_load_drivers);
	581	EXPORT_SYMBOL(snd_seq_device_new);
	582	EXPORT_SYMBOL(snd_seq_device_register_driver);
	583	EXPORT_SYMBOL(snd_seq_device_unregister_driver);
	584	#ifdef CONFIG_KMOD
	585	EXPORT_SYMBOL(snd_seq_autoload_lock);
	586	EXPORT_SYMBOL(snd_seq_autoload_unlock);
	587	#endif