2 * Advanced Linux Sound Architecture
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/time.h>
25 #include <linux/device.h>
26 #include <linux/module.h>
27 #include <sound/core.h>
28 #include <sound/minors.h>
29 #include <sound/info.h>
30 #include <sound/control.h>
31 #include <sound/initval.h>
32 #include <linux/kmod.h>
33 #include <linux/mutex.h>
35 static int major
= CONFIG_SND_MAJOR
;
37 EXPORT_SYMBOL(snd_major
);
39 static int cards_limit
= 1;
41 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
42 MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
43 MODULE_LICENSE("GPL");
44 module_param(major
, int, 0444);
45 MODULE_PARM_DESC(major
, "Major # for sound driver.");
46 module_param(cards_limit
, int, 0444);
47 MODULE_PARM_DESC(cards_limit
, "Count of auto-loadable soundcards.");
48 MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR
);
50 /* this one holds the actual max. card number currently available.
51 * as default, it's identical with cards_limit option. when more
52 * modules are loaded manually, this limit number increases, too.
55 EXPORT_SYMBOL(snd_ecards_limit
);
57 static struct snd_minor
*snd_minors
[SNDRV_OS_MINORS
];
58 static DEFINE_MUTEX(sound_mutex
);
63 * snd_request_card - try to load the card module
64 * @card: the card number
66 * Tries to load the module "snd-card-X" for the given card number
67 * via request_module. Returns immediately if already loaded.
69 void snd_request_card(int card
)
71 if (snd_card_locked(card
))
73 if (card
< 0 || card
>= cards_limit
)
75 request_module("snd-card-%i", card
);
78 EXPORT_SYMBOL(snd_request_card
);
80 static void snd_request_other(int minor
)
85 case SNDRV_MINOR_SEQUENCER
: str
= "snd-seq"; break;
86 case SNDRV_MINOR_TIMER
: str
= "snd-timer"; break;
92 #endif /* modular kernel */
95 * snd_lookup_minor_data - get user data of a registered device
96 * @minor: the minor number
97 * @type: device type (SNDRV_DEVICE_TYPE_XXX)
99 * Checks that a minor device with the specified type is registered, and returns
100 * its user data pointer.
102 * This function increments the reference counter of the card instance
103 * if an associated instance with the given minor number and type is found.
104 * The caller must call snd_card_unref() appropriately later.
106 * Return: The user data pointer if the specified device is found. %NULL
109 void *snd_lookup_minor_data(unsigned int minor
, int type
)
111 struct snd_minor
*mreg
;
114 if (minor
>= ARRAY_SIZE(snd_minors
))
116 mutex_lock(&sound_mutex
);
117 mreg
= snd_minors
[minor
];
118 if (mreg
&& mreg
->type
== type
) {
119 private_data
= mreg
->private_data
;
120 if (private_data
&& mreg
->card_ptr
)
121 get_device(&mreg
->card_ptr
->card_dev
);
124 mutex_unlock(&sound_mutex
);
128 EXPORT_SYMBOL(snd_lookup_minor_data
);
130 #ifdef CONFIG_MODULES
131 static struct snd_minor
*autoload_device(unsigned int minor
)
134 mutex_unlock(&sound_mutex
); /* release lock temporarily */
135 dev
= SNDRV_MINOR_DEVICE(minor
);
136 if (dev
== SNDRV_MINOR_CONTROL
) {
138 int card
= SNDRV_MINOR_CARD(minor
);
139 if (snd_cards
[card
] == NULL
)
140 snd_request_card(card
);
141 } else if (dev
== SNDRV_MINOR_GLOBAL
) {
143 snd_request_other(minor
);
145 mutex_lock(&sound_mutex
); /* reacuire lock */
146 return snd_minors
[minor
];
148 #else /* !CONFIG_MODULES */
149 #define autoload_device(minor) NULL
150 #endif /* CONFIG_MODULES */
152 static int snd_open(struct inode
*inode
, struct file
*file
)
154 unsigned int minor
= iminor(inode
);
155 struct snd_minor
*mptr
= NULL
;
156 const struct file_operations
*new_fops
;
159 if (minor
>= ARRAY_SIZE(snd_minors
))
161 mutex_lock(&sound_mutex
);
162 mptr
= snd_minors
[minor
];
164 mptr
= autoload_device(minor
);
166 mutex_unlock(&sound_mutex
);
170 new_fops
= fops_get(mptr
->f_ops
);
171 mutex_unlock(&sound_mutex
);
174 replace_fops(file
, new_fops
);
176 if (file
->f_op
->open
)
177 err
= file
->f_op
->open(inode
, file
);
181 static const struct file_operations snd_fops
=
183 .owner
= THIS_MODULE
,
185 .llseek
= noop_llseek
,
188 #ifdef CONFIG_SND_DYNAMIC_MINORS
189 static int snd_find_free_minor(int type
)
193 /* static minors for module auto loading */
194 if (type
== SNDRV_DEVICE_TYPE_SEQUENCER
)
195 return SNDRV_MINOR_SEQUENCER
;
196 if (type
== SNDRV_DEVICE_TYPE_TIMER
)
197 return SNDRV_MINOR_TIMER
;
199 for (minor
= 0; minor
< ARRAY_SIZE(snd_minors
); ++minor
) {
200 /* skip static minors still used for module auto loading */
201 if (SNDRV_MINOR_DEVICE(minor
) == SNDRV_MINOR_CONTROL
)
203 if (minor
== SNDRV_MINOR_SEQUENCER
||
204 minor
== SNDRV_MINOR_TIMER
)
206 if (!snd_minors
[minor
])
212 static int snd_kernel_minor(int type
, struct snd_card
*card
, int dev
)
217 case SNDRV_DEVICE_TYPE_SEQUENCER
:
218 case SNDRV_DEVICE_TYPE_TIMER
:
221 case SNDRV_DEVICE_TYPE_CONTROL
:
222 if (snd_BUG_ON(!card
))
224 minor
= SNDRV_MINOR(card
->number
, type
);
226 case SNDRV_DEVICE_TYPE_HWDEP
:
227 case SNDRV_DEVICE_TYPE_RAWMIDI
:
228 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK
:
229 case SNDRV_DEVICE_TYPE_PCM_CAPTURE
:
230 case SNDRV_DEVICE_TYPE_COMPRESS
:
231 if (snd_BUG_ON(!card
))
233 minor
= SNDRV_MINOR(card
->number
, type
+ dev
);
238 if (snd_BUG_ON(minor
< 0 || minor
>= SNDRV_OS_MINORS
))
245 * snd_register_device_for_dev - Register the ALSA device file for the card
246 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
247 * @card: the card instance
248 * @dev: the device index
249 * @f_ops: the file operations
250 * @private_data: user pointer for f_ops->open()
251 * @device: the device to register, NULL to create a new one
252 * @parent: the &struct device to link this new device to (only for device=NULL)
253 * @name: the device file name (only for device=NULL)
255 * Registers an ALSA device file for the given card.
256 * The operators have to be set in reg parameter.
258 * Return: Zero if successful, or a negative error code on failure.
260 int snd_register_device_for_dev(int type
, struct snd_card
*card
, int dev
,
261 const struct file_operations
*f_ops
,
262 void *private_data
, struct device
*device
,
263 struct device
*parent
, const char *name
)
267 struct snd_minor
*preg
;
269 preg
= kmalloc(sizeof *preg
, GFP_KERNEL
);
273 preg
->card
= card
? card
->number
: -1;
276 preg
->private_data
= private_data
;
277 preg
->card_ptr
= card
;
278 mutex_lock(&sound_mutex
);
279 #ifdef CONFIG_SND_DYNAMIC_MINORS
280 minor
= snd_find_free_minor(type
);
282 minor
= snd_kernel_minor(type
, card
, dev
);
283 if (minor
>= 0 && snd_minors
[minor
])
292 preg
->created
= false;
294 device
->devt
= MKDEV(major
, minor
);
295 err
= device_add(device
);
297 preg
->created
= true;
298 preg
->dev
= device_create(sound_class
, parent
,
299 MKDEV(major
, minor
), private_data
,
301 if (IS_ERR(preg
->dev
))
302 err
= PTR_ERR(preg
->dev
);
307 snd_minors
[minor
] = preg
;
309 mutex_unlock(&sound_mutex
);
315 EXPORT_SYMBOL(snd_register_device_for_dev
);
317 /* find the matching minor record
318 * return the index of snd_minor, or -1 if not found
320 static int find_snd_minor(int type
, struct snd_card
*card
, int dev
)
323 struct snd_minor
*mptr
;
325 cardnum
= card
? card
->number
: -1;
326 for (minor
= 0; minor
< ARRAY_SIZE(snd_minors
); ++minor
)
327 if ((mptr
= snd_minors
[minor
]) != NULL
&&
328 mptr
->type
== type
&&
329 mptr
->card
== cardnum
&&
336 * snd_unregister_device - unregister the device on the given card
337 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
338 * @card: the card instance
339 * @dev: the device index
341 * Unregisters the device file already registered via
342 * snd_register_device().
344 * Return: Zero if successful, or a negative error code on failure.
346 int snd_unregister_device(int type
, struct snd_card
*card
, int dev
)
349 struct snd_minor
*preg
;
351 mutex_lock(&sound_mutex
);
352 minor
= find_snd_minor(type
, card
, dev
);
354 mutex_unlock(&sound_mutex
);
358 preg
= snd_minors
[minor
];
359 if (preg
&& !preg
->created
)
360 device_del(preg
->dev
);
362 device_destroy(sound_class
, MKDEV(major
, minor
));
364 kfree(snd_minors
[minor
]);
365 snd_minors
[minor
] = NULL
;
366 mutex_unlock(&sound_mutex
);
370 EXPORT_SYMBOL(snd_unregister_device
);
373 * snd_get_device - get the assigned device to the given type and device number
374 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
375 * @card:the card instance
376 * @dev: the device index
378 * The caller needs to release it via put_device() after using it.
380 struct device
*snd_get_device(int type
, struct snd_card
*card
, int dev
)
383 struct device
*d
= NULL
;
385 mutex_lock(&sound_mutex
);
386 minor
= find_snd_minor(type
, card
, dev
);
388 d
= snd_minors
[minor
]->dev
;
392 mutex_unlock(&sound_mutex
);
395 EXPORT_SYMBOL(snd_get_device
);
397 #ifdef CONFIG_PROC_FS
402 static struct snd_info_entry
*snd_minor_info_entry
;
404 static const char *snd_device_type_name(int type
)
407 case SNDRV_DEVICE_TYPE_CONTROL
:
409 case SNDRV_DEVICE_TYPE_HWDEP
:
410 return "hardware dependent";
411 case SNDRV_DEVICE_TYPE_RAWMIDI
:
413 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK
:
414 return "digital audio playback";
415 case SNDRV_DEVICE_TYPE_PCM_CAPTURE
:
416 return "digital audio capture";
417 case SNDRV_DEVICE_TYPE_SEQUENCER
:
419 case SNDRV_DEVICE_TYPE_TIMER
:
426 static void snd_minor_info_read(struct snd_info_entry
*entry
, struct snd_info_buffer
*buffer
)
429 struct snd_minor
*mptr
;
431 mutex_lock(&sound_mutex
);
432 for (minor
= 0; minor
< SNDRV_OS_MINORS
; ++minor
) {
433 if (!(mptr
= snd_minors
[minor
]))
435 if (mptr
->card
>= 0) {
436 if (mptr
->device
>= 0)
437 snd_iprintf(buffer
, "%3i: [%2i-%2i]: %s\n",
438 minor
, mptr
->card
, mptr
->device
,
439 snd_device_type_name(mptr
->type
));
441 snd_iprintf(buffer
, "%3i: [%2i] : %s\n",
443 snd_device_type_name(mptr
->type
));
445 snd_iprintf(buffer
, "%3i: : %s\n", minor
,
446 snd_device_type_name(mptr
->type
));
448 mutex_unlock(&sound_mutex
);
451 int __init
snd_minor_info_init(void)
453 struct snd_info_entry
*entry
;
455 entry
= snd_info_create_module_entry(THIS_MODULE
, "devices", NULL
);
457 entry
->c
.text
.read
= snd_minor_info_read
;
458 if (snd_info_register(entry
) < 0) {
459 snd_info_free_entry(entry
);
463 snd_minor_info_entry
= entry
;
467 int __exit
snd_minor_info_done(void)
469 snd_info_free_entry(snd_minor_info_entry
);
472 #endif /* CONFIG_PROC_FS */
478 static int __init
alsa_sound_init(void)
481 snd_ecards_limit
= cards_limit
;
482 if (register_chrdev(major
, "alsa", &snd_fops
)) {
483 pr_err("ALSA core: unable to register native major device number %d\n", major
);
486 if (snd_info_init() < 0) {
487 unregister_chrdev(major
, "alsa");
490 snd_info_minor_register();
492 pr_info("Advanced Linux Sound Architecture Driver Initialized.\n");
497 static void __exit
alsa_sound_exit(void)
499 snd_info_minor_unregister();
501 unregister_chrdev(major
, "alsa");
504 subsys_initcall(alsa_sound_init
);
505 module_exit(alsa_sound_exit
);