[deliverable/linux.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 <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 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 ops_list *ops;

	mutex_lock(&ops_mutex);
	list_for_each_entry(ops, &opslist, 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_MODULES
/* 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_MODULES
	struct ops_list *ops;

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

	mutex_lock(&ops_mutex);
	list_for_each_entry(ops, &opslist, 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,
	};

	if (result)
		*result = NULL;

	if (snd_BUG_ON(!id))
		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;

	if (snd_BUG_ON(!dev))
		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;
}

/*
 * 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 ops_list *ops;
	struct snd_seq_device *dev;

	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_entry(dev, &ops->dev_list, 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 = kzalloc(sizeof(*ops), GFP_KERNEL);
	if (ops == NULL)
		return ops;

	/* set up driver entry */
	strlcpy(ops->id, id, sizeof(ops->id));
	mutex_init(&ops->reg_mutex);
	/*
	 * The ->reg_mutex locking rules are per-driver, so we create
	 * separate per-driver lock classes:
	 */
	lockdep_set_class(&ops->reg_mutex, (struct lock_class_key *)id);

	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 ops_list *ops;
	struct snd_seq_device *dev;

	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_entry(dev, &ops->dev_list, 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 ops_list *ops;

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