blob: 1e4bc402f00f21eed70a88a013731a2b39318c23 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Ingo Molnar1a60d4c2006-01-16 16:29:08 +010048#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
51MODULE_DESCRIPTION("ALSA sequencer device management");
52MODULE_LICENSE("GPL");
53
Linus Torvalds1da177e2005-04-16 15:20:36 -070054/* 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
60struct 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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +010067 struct snd_seq_dev_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
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 */
Ingo Molnar1a60d4c2006-01-16 16:29:08 +010073 struct mutex reg_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75 struct list_head list; /* next driver */
76};
77
78
79static LIST_HEAD(opslist);
80static int num_ops;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +010081static DEFINE_MUTEX(ops_mutex);
Takashi Iwai04f141a2005-12-01 10:43:51 +010082#ifdef CONFIG_PROC_FS
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +010083static struct snd_info_entry *info_entry = NULL;
Takashi Iwai04f141a2005-12-01 10:43:51 +010084#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86/*
87 * prototypes
88 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +010089static int snd_seq_device_free(struct snd_seq_device *dev);
90static int snd_seq_device_dev_free(struct snd_device *device);
91static int snd_seq_device_dev_register(struct snd_device *device);
92static int snd_seq_device_dev_disconnect(struct snd_device *device);
93static int snd_seq_device_dev_unregister(struct snd_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +010095static int init_device(struct snd_seq_device *dev, struct ops_list *ops);
96static int free_device(struct snd_seq_device *dev, struct ops_list *ops);
97static struct ops_list *find_driver(char *id, int create_if_empty);
98static struct ops_list *create_driver(char *id);
99static void unlock_driver(struct ops_list *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static void remove_drivers(void);
101
102/*
103 * show all drivers and their status
104 */
105
Takashi Iwai04f141a2005-12-01 10:43:51 +0100106#ifdef CONFIG_PROC_FS
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100107static void snd_seq_device_info(struct snd_info_entry *entry,
108 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 struct list_head *head;
111
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100112 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 list_for_each(head, &opslist) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100114 struct ops_list *ops = list_entry(head, struct ops_list, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 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 }
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100122 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
Takashi Iwai04f141a2005-12-01 10:43:51 +0100124#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126/*
127 * load all registered drivers (called from seq_clientmgr.c)
128 */
129
130#ifdef CONFIG_KMOD
131/* avoid auto-loading during module_init() */
132static int snd_seq_in_init;
133void snd_seq_autoload_lock(void)
134{
135 snd_seq_in_init++;
136}
137
138void snd_seq_autoload_unlock(void)
139{
140 snd_seq_in_init--;
141}
142#endif
143
144void 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
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100158 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 list_for_each(head, &opslist) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100160 struct ops_list *ops = list_entry(head, struct ops_list, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 if (! (ops->driver & DRIVER_LOADED) &&
162 ! (ops->driver & DRIVER_REQUESTED)) {
163 ops->used++;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100164 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 ops->driver |= DRIVER_REQUESTED;
166 request_module("snd-%s", ops->id);
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100167 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 ops->used--;
169 }
170 }
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100171 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172#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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100182int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
183 struct snd_seq_device **result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100185 struct snd_seq_device *dev;
186 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 int err;
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100188 static struct snd_device_ops dops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 .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
Takashi Iwaiecca82b2005-09-09 14:20:49 +0200204 dev = kzalloc(sizeof(*dev)*2 + argsize, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 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 */
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100218 mutex_lock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 list_add_tail(&dev->list, &ops->dev_list);
220 ops->num_devices++;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100221 mutex_unlock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100239static int snd_seq_device_free(struct snd_seq_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100241 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
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 */
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100250 mutex_lock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 list_del(&dev->list);
252 ops->num_devices--;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100253 mutex_unlock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
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
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100265static int snd_seq_device_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100267 struct snd_seq_device *dev = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 return snd_seq_device_free(dev);
269}
270
271/*
272 * register the device
273 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100274static int snd_seq_device_dev_register(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100276 struct snd_seq_device *dev = device->device_data;
277 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100296static int snd_seq_device_dev_disconnect(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100298 struct snd_seq_device *dev = device->device_data;
299 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100314static int snd_seq_device_dev_unregister(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100316 struct snd_seq_device *dev = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 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 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100325int snd_seq_device_register_driver(char *id, struct snd_seq_dev_ops *entry,
326 int argsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
328 struct list_head *head;
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100329 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
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
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100348 mutex_lock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 /* 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) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100356 struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 init_device(dev, ops);
358 }
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100359 mutex_unlock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 unlock_driver(ops);
362 snd_seq_autoload_unlock();
363
364 return 0;
365}
366
367
368/*
369 * create driver record
370 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100371static struct ops_list * create_driver(char *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100373 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
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));
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100382 mutex_init(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 ops->driver = DRIVER_EMPTY;
384 INIT_LIST_HEAD(&ops->dev_list);
385 /* lock this instance */
386 ops->used = 1;
387
388 /* register driver entry */
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100389 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 list_add_tail(&ops->list, &opslist);
391 num_ops++;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100392 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 return ops;
395}
396
397
398/*
399 * unregister the specified driver
400 */
401int snd_seq_device_unregister_driver(char *id)
402{
403 struct list_head *head;
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100404 struct ops_list *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 ops = find_driver(id, 0);
407 if (ops == NULL)
408 return -ENXIO;
409 if (! (ops->driver & DRIVER_LOADED) ||
410 (ops->driver & DRIVER_LOCKED)) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100411 snd_printk(KERN_ERR "driver_unregister: cannot unload driver '%s': status=%x\n",
412 id, ops->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 unlock_driver(ops);
414 return -EBUSY;
415 }
416
417 /* close and release all devices associated with this driver */
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100418 mutex_lock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 ops->driver |= DRIVER_LOCKED; /* do not remove this driver recursively */
420 list_for_each(head, &ops->dev_list) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100421 struct snd_seq_device *dev = list_entry(head, struct snd_seq_device, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 free_device(dev, ops);
423 }
424
425 ops->driver = 0;
426 if (ops->num_init_devices > 0)
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100427 snd_printk(KERN_ERR "free_driver: init_devices > 0!! (%d)\n",
428 ops->num_init_devices);
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100429 mutex_unlock(&ops->reg_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
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 */
443static void remove_drivers(void)
444{
445 struct list_head *head;
446
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100447 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 head = opslist.next;
449 while (head != &opslist) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100450 struct ops_list *ops = list_entry(head, struct ops_list, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 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 }
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100460 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
463/*
464 * initialize the device - call init_device operator
465 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100466static int init_device(struct snd_seq_device *dev, struct ops_list *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
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) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100473 snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
474 dev->name, ops->id, ops->argsize, dev->argsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 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 {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100481 snd_printk(KERN_ERR "init_device failed: %s: %s\n",
482 dev->name, dev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 }
484
485 return 0;
486}
487
488/*
489 * release the device - call free_device operator
490 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100491static int free_device(struct snd_seq_device *dev, struct ops_list *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
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) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100500 snd_printk(KERN_ERR "incompatible device '%s' for plug-in '%s' (%d %d)\n",
501 dev->name, ops->id, ops->argsize, dev->argsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 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 {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100509 snd_printk(KERN_ERR "free_device failed: %s: %s\n",
510 dev->name, dev->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
512
513 return 0;
514}
515
516/*
517 * find the matching driver with given id
518 */
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100519static struct ops_list * find_driver(char *id, int create_if_empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
521 struct list_head *head;
522
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100523 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 list_for_each(head, &opslist) {
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100525 struct ops_list *ops = list_entry(head, struct ops_list, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 if (strcmp(ops->id, id) == 0) {
527 ops->used++;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100528 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 return ops;
530 }
531 }
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100532 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 if (create_if_empty)
534 return create_driver(id);
535 return NULL;
536}
537
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100538static void unlock_driver(struct ops_list *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539{
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100540 mutex_lock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 ops->used--;
Ingo Molnar1a60d4c2006-01-16 16:29:08 +0100542 mutex_unlock(&ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
545
546/*
547 * module part
548 */
549
550static int __init alsa_seq_device_init(void)
551{
Takashi Iwai04f141a2005-12-01 10:43:51 +0100552#ifdef CONFIG_PROC_FS
Takashi Iwaic7e0b5b2005-11-17 14:04:02 +0100553 info_entry = snd_info_create_module_entry(THIS_MODULE, "drivers",
554 snd_seq_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (info_entry == NULL)
556 return -ENOMEM;
557 info_entry->content = SNDRV_INFO_CONTENT_TEXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 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 }
Takashi Iwai04f141a2005-12-01 10:43:51 +0100563#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return 0;
565}
566
567static void __exit alsa_seq_device_exit(void)
568{
569 remove_drivers();
Takashi Iwai04f141a2005-12-01 10:43:51 +0100570#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 snd_info_unregister(info_entry);
Takashi Iwai04f141a2005-12-01 10:43:51 +0100572#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (num_ops)
574 snd_printk(KERN_ERR "drivers not released (%d)\n", num_ops);
575}
576
577module_init(alsa_seq_device_init)
578module_exit(alsa_seq_device_exit)
579
580EXPORT_SYMBOL(snd_seq_device_load_drivers);
581EXPORT_SYMBOL(snd_seq_device_new);
582EXPORT_SYMBOL(snd_seq_device_register_driver);
583EXPORT_SYMBOL(snd_seq_device_unregister_driver);
584#ifdef CONFIG_KMOD
585EXPORT_SYMBOL(snd_seq_autoload_lock);
586EXPORT_SYMBOL(snd_seq_autoload_unlock);
587#endif