Branch data Line data Source code
1 : : /*
2 : : * Advanced Linux Sound Architecture
3 : : * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 : : *
5 : : *
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.
10 : : *
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.
15 : : *
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
19 : : *
20 : : */
21 : :
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>
34 : :
35 : : static int major = CONFIG_SND_MAJOR;
36 : : int snd_major;
37 : : EXPORT_SYMBOL(snd_major);
38 : :
39 : : static int cards_limit = 1;
40 : :
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);
49 : :
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.
53 : : */
54 : : int snd_ecards_limit;
55 : : EXPORT_SYMBOL(snd_ecards_limit);
56 : :
57 : : static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
58 : : static DEFINE_MUTEX(sound_mutex);
59 : :
60 : : #ifdef CONFIG_MODULES
61 : :
62 : : /**
63 : : * snd_request_card - try to load the card module
64 : : * @card: the card number
65 : : *
66 : : * Tries to load the module "snd-card-X" for the given card number
67 : : * via request_module. Returns immediately if already loaded.
68 : : */
69 : 0 : void snd_request_card(int card)
70 : : {
71 [ # # ]: 0 : if (snd_card_locked(card))
72 : : return;
73 [ # # ][ # # ]: 0 : if (card < 0 || card >= cards_limit)
74 : : return;
75 : 0 : request_module("snd-card-%i", card);
76 : : }
77 : :
78 : : EXPORT_SYMBOL(snd_request_card);
79 : :
80 : 0 : static void snd_request_other(int minor)
81 : : {
82 : : char *str;
83 : :
84 [ # # # ]: 0 : switch (minor) {
85 : : case SNDRV_MINOR_SEQUENCER: str = "snd-seq"; break;
86 : 0 : case SNDRV_MINOR_TIMER: str = "snd-timer"; break;
87 : 0 : default: return;
88 : : }
89 : 0 : request_module(str);
90 : : }
91 : :
92 : : #endif /* modular kernel */
93 : :
94 : : /**
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)
98 : : *
99 : : * Checks that a minor device with the specified type is registered, and returns
100 : : * its user data pointer.
101 : : *
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.
105 : : *
106 : : * Return: The user data pointer if the specified device is found. %NULL
107 : : * otherwise.
108 : : */
109 : 0 : void *snd_lookup_minor_data(unsigned int minor, int type)
110 : : {
111 : : struct snd_minor *mreg;
112 : : void *private_data;
113 : :
114 [ # # ]: 0 : if (minor >= ARRAY_SIZE(snd_minors))
115 : : return NULL;
116 : 0 : mutex_lock(&sound_mutex);
117 : 0 : mreg = snd_minors[minor];
118 [ # # ][ # # ]: 0 : if (mreg && mreg->type == type) {
119 : 0 : private_data = mreg->private_data;
120 [ # # ][ # # ]: 0 : if (private_data && mreg->card_ptr)
121 : 0 : atomic_inc(&mreg->card_ptr->refcount);
122 : : } else
123 : : private_data = NULL;
124 : 0 : mutex_unlock(&sound_mutex);
125 : 0 : return private_data;
126 : : }
127 : :
128 : : EXPORT_SYMBOL(snd_lookup_minor_data);
129 : :
130 : : #ifdef CONFIG_MODULES
131 : 0 : static struct snd_minor *autoload_device(unsigned int minor)
132 : : {
133 : : int dev;
134 : 0 : mutex_unlock(&sound_mutex); /* release lock temporarily */
135 : 0 : dev = SNDRV_MINOR_DEVICE(minor);
136 [ # # ]: 0 : if (dev == SNDRV_MINOR_CONTROL) {
137 : : /* /dev/aloadC? */
138 : 0 : int card = SNDRV_MINOR_CARD(minor);
139 [ # # ]: 0 : if (snd_cards[card] == NULL)
140 : 0 : snd_request_card(card);
141 [ # # ]: 0 : } else if (dev == SNDRV_MINOR_GLOBAL) {
142 : : /* /dev/aloadSEQ */
143 : 0 : snd_request_other(minor);
144 : : }
145 : 0 : mutex_lock(&sound_mutex); /* reacuire lock */
146 : 0 : return snd_minors[minor];
147 : : }
148 : : #else /* !CONFIG_MODULES */
149 : : #define autoload_device(minor) NULL
150 : : #endif /* CONFIG_MODULES */
151 : :
152 : 0 : static int snd_open(struct inode *inode, struct file *file)
153 : : {
154 : : unsigned int minor = iminor(inode);
155 : : struct snd_minor *mptr = NULL;
156 : : const struct file_operations *new_fops;
157 : : int err = 0;
158 : :
159 [ # # ]: 0 : if (minor >= ARRAY_SIZE(snd_minors))
160 : : return -ENODEV;
161 : 0 : mutex_lock(&sound_mutex);
162 : 0 : mptr = snd_minors[minor];
163 [ # # ]: 0 : if (mptr == NULL) {
164 : 0 : mptr = autoload_device(minor);
165 [ # # ]: 0 : if (!mptr) {
166 : 0 : mutex_unlock(&sound_mutex);
167 : 0 : return -ENODEV;
168 : : }
169 : : }
170 [ # # ][ # # ]: 0 : new_fops = fops_get(mptr->f_ops);
171 : 0 : mutex_unlock(&sound_mutex);
172 [ # # ]: 0 : if (!new_fops)
173 : : return -ENODEV;
174 [ # # ][ # # ]: 0 : replace_fops(file, new_fops);
175 : :
176 [ # # ]: 0 : if (file->f_op->open)
177 : 0 : err = file->f_op->open(inode, file);
178 : 0 : return err;
179 : : }
180 : :
181 : : static const struct file_operations snd_fops =
182 : : {
183 : : .owner = THIS_MODULE,
184 : : .open = snd_open,
185 : : .llseek = noop_llseek,
186 : : };
187 : :
188 : : #ifdef CONFIG_SND_DYNAMIC_MINORS
189 : : static int snd_find_free_minor(int type)
190 : : {
191 : : int minor;
192 : :
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;
198 : :
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)
202 : : continue;
203 : : if (minor == SNDRV_MINOR_SEQUENCER ||
204 : : minor == SNDRV_MINOR_TIMER)
205 : : continue;
206 : : if (!snd_minors[minor])
207 : : return minor;
208 : : }
209 : : return -EBUSY;
210 : : }
211 : : #else
212 : 0 : static int snd_kernel_minor(int type, struct snd_card *card, int dev)
213 : : {
214 : : int minor;
215 : :
216 [ # # # # ]: 0 : switch (type) {
217 : : case SNDRV_DEVICE_TYPE_SEQUENCER:
218 : : case SNDRV_DEVICE_TYPE_TIMER:
219 : : minor = type;
220 : : break;
221 : : case SNDRV_DEVICE_TYPE_CONTROL:
222 [ # # ]: 0 : if (snd_BUG_ON(!card))
223 : : return -EINVAL;
224 : 0 : minor = SNDRV_MINOR(card->number, type);
225 : 0 : break;
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 [ # # ]: 0 : if (snd_BUG_ON(!card))
232 : : return -EINVAL;
233 : 0 : minor = SNDRV_MINOR(card->number, type + dev);
234 : 0 : break;
235 : : default:
236 : : return -EINVAL;
237 : : }
238 [ # # ]: 0 : if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
239 : : return -EINVAL;
240 : 0 : return minor;
241 : : }
242 : : #endif
243 : :
244 : : /**
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 : : * @name: the device file name
252 : : * @device: the &struct device to link this new device to
253 : : *
254 : : * Registers an ALSA device file for the given card.
255 : : * The operators have to be set in reg parameter.
256 : : *
257 : : * Return: Zero if successful, or a negative error code on failure.
258 : : */
259 : 0 : int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
260 : : const struct file_operations *f_ops,
261 : : void *private_data,
262 : : const char *name, struct device *device)
263 : : {
264 : : int minor;
265 : : struct snd_minor *preg;
266 : :
267 [ # # ]: 0 : if (snd_BUG_ON(!name))
268 : : return -EINVAL;
269 : : preg = kmalloc(sizeof *preg, GFP_KERNEL);
270 [ # # ]: 0 : if (preg == NULL)
271 : : return -ENOMEM;
272 : 0 : preg->type = type;
273 [ # # ]: 0 : preg->card = card ? card->number : -1;
274 : 0 : preg->device = dev;
275 : 0 : preg->f_ops = f_ops;
276 : 0 : preg->private_data = private_data;
277 : 0 : preg->card_ptr = card;
278 : 0 : mutex_lock(&sound_mutex);
279 : : #ifdef CONFIG_SND_DYNAMIC_MINORS
280 : : minor = snd_find_free_minor(type);
281 : : #else
282 : 0 : minor = snd_kernel_minor(type, card, dev);
283 [ # # ][ # # ]: 0 : if (minor >= 0 && snd_minors[minor])
284 : : minor = -EBUSY;
285 : : #endif
286 [ # # ]: 0 : if (minor < 0) {
287 : 0 : mutex_unlock(&sound_mutex);
288 : 0 : kfree(preg);
289 : 0 : return minor;
290 : : }
291 : 0 : snd_minors[minor] = preg;
292 : 0 : preg->dev = device_create(sound_class, device, MKDEV(major, minor),
293 : : private_data, "%s", name);
294 [ # # ]: 0 : if (IS_ERR(preg->dev)) {
295 : 0 : snd_minors[minor] = NULL;
296 : 0 : mutex_unlock(&sound_mutex);
297 : 0 : minor = PTR_ERR(preg->dev);
298 : 0 : kfree(preg);
299 : 0 : return minor;
300 : : }
301 : :
302 : 0 : mutex_unlock(&sound_mutex);
303 : 0 : return 0;
304 : : }
305 : :
306 : : EXPORT_SYMBOL(snd_register_device_for_dev);
307 : :
308 : : /* find the matching minor record
309 : : * return the index of snd_minor, or -1 if not found
310 : : */
311 : 0 : static int find_snd_minor(int type, struct snd_card *card, int dev)
312 : : {
313 : : int cardnum, minor;
314 : : struct snd_minor *mptr;
315 : :
316 [ # # ]: 0 : cardnum = card ? card->number : -1;
317 [ # # ]: 0 : for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
318 [ # # ][ # # ]: 0 : if ((mptr = snd_minors[minor]) != NULL &&
319 [ # # ]: 0 : mptr->type == type &&
320 [ # # ]: 0 : mptr->card == cardnum &&
321 : 0 : mptr->device == dev)
322 : : return minor;
323 : : return -1;
324 : : }
325 : :
326 : : /**
327 : : * snd_unregister_device - unregister the device on the given card
328 : : * @type: the device type, SNDRV_DEVICE_TYPE_XXX
329 : : * @card: the card instance
330 : : * @dev: the device index
331 : : *
332 : : * Unregisters the device file already registered via
333 : : * snd_register_device().
334 : : *
335 : : * Return: Zero if successful, or a negative error code on failure.
336 : : */
337 : 0 : int snd_unregister_device(int type, struct snd_card *card, int dev)
338 : : {
339 : : int minor;
340 : :
341 : 0 : mutex_lock(&sound_mutex);
342 : 0 : minor = find_snd_minor(type, card, dev);
343 [ # # ]: 0 : if (minor < 0) {
344 : 0 : mutex_unlock(&sound_mutex);
345 : 0 : return -EINVAL;
346 : : }
347 : :
348 : 0 : device_destroy(sound_class, MKDEV(major, minor));
349 : :
350 : 0 : kfree(snd_minors[minor]);
351 : 0 : snd_minors[minor] = NULL;
352 : 0 : mutex_unlock(&sound_mutex);
353 : 0 : return 0;
354 : : }
355 : :
356 : : EXPORT_SYMBOL(snd_unregister_device);
357 : :
358 : 0 : int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
359 : : struct device_attribute *attr)
360 : : {
361 : : int minor, ret = -EINVAL;
362 : : struct device *d;
363 : :
364 : 0 : mutex_lock(&sound_mutex);
365 : 0 : minor = find_snd_minor(type, card, dev);
366 [ # # ][ # # ]: 0 : if (minor >= 0 && (d = snd_minors[minor]->dev) != NULL)
367 : 0 : ret = device_create_file(d, attr);
368 : 0 : mutex_unlock(&sound_mutex);
369 : 0 : return ret;
370 : :
371 : : }
372 : :
373 : : EXPORT_SYMBOL(snd_add_device_sysfs_file);
374 : :
375 : : #ifdef CONFIG_PROC_FS
376 : : /*
377 : : * INFO PART
378 : : */
379 : :
380 : : static struct snd_info_entry *snd_minor_info_entry;
381 : :
382 : : static const char *snd_device_type_name(int type)
383 : : {
384 : : switch (type) {
385 : : case SNDRV_DEVICE_TYPE_CONTROL:
386 : : return "control";
387 : : case SNDRV_DEVICE_TYPE_HWDEP:
388 : : return "hardware dependent";
389 : : case SNDRV_DEVICE_TYPE_RAWMIDI:
390 : : return "raw midi";
391 : : case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
392 : : return "digital audio playback";
393 : : case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
394 : : return "digital audio capture";
395 : : case SNDRV_DEVICE_TYPE_SEQUENCER:
396 : : return "sequencer";
397 : : case SNDRV_DEVICE_TYPE_TIMER:
398 : : return "timer";
399 : : default:
400 : : return "?";
401 : : }
402 : : }
403 : :
404 : 0 : static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
405 : : {
406 : : int minor;
407 : : struct snd_minor *mptr;
408 : :
409 : 1 : mutex_lock(&sound_mutex);
410 [ + + ]: 257 : for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
411 [ + + ]: 256 : if (!(mptr = snd_minors[minor]))
412 : 252 : continue;
413 [ + + ]: 4 : if (mptr->card >= 0) {
414 [ + + ]: 3 : if (mptr->device >= 0)
415 [ + - ]: 2 : snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
416 : : minor, mptr->card, mptr->device,
417 : : snd_device_type_name(mptr->type));
418 : : else
419 [ + - ]: 1 : snd_iprintf(buffer, "%3i: [%2i] : %s\n",
420 : : minor, mptr->card,
421 : : snd_device_type_name(mptr->type));
422 : : } else
423 [ + - ]: 1 : snd_iprintf(buffer, "%3i: : %s\n", minor,
424 : : snd_device_type_name(mptr->type));
425 : : }
426 : 1 : mutex_unlock(&sound_mutex);
427 : 1 : }
428 : :
429 : 0 : int __init snd_minor_info_init(void)
430 : : {
431 : : struct snd_info_entry *entry;
432 : :
433 : 0 : entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
434 [ # # ]: 0 : if (entry) {
435 : 0 : entry->c.text.read = snd_minor_info_read;
436 [ # # ]: 0 : if (snd_info_register(entry) < 0) {
437 : 0 : snd_info_free_entry(entry);
438 : : entry = NULL;
439 : : }
440 : : }
441 : 0 : snd_minor_info_entry = entry;
442 : 0 : return 0;
443 : : }
444 : :
445 : 0 : int __exit snd_minor_info_done(void)
446 : : {
447 : 0 : snd_info_free_entry(snd_minor_info_entry);
448 : 0 : return 0;
449 : : }
450 : : #endif /* CONFIG_PROC_FS */
451 : :
452 : : /*
453 : : * INIT PART
454 : : */
455 : :
456 : 0 : static int __init alsa_sound_init(void)
457 : : {
458 : 0 : snd_major = major;
459 : 0 : snd_ecards_limit = cards_limit;
460 [ # # ]: 0 : if (register_chrdev(major, "alsa", &snd_fops)) {
461 : 0 : snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
462 : 0 : return -EIO;
463 : : }
464 [ # # ]: 0 : if (snd_info_init() < 0) {
465 : 0 : unregister_chrdev(major, "alsa");
466 : 0 : return -ENOMEM;
467 : : }
468 : : snd_info_minor_register();
469 : : #ifndef MODULE
470 : 0 : printk(KERN_INFO "Advanced Linux Sound Architecture Driver Initialized.\n");
471 : : #endif
472 : 0 : return 0;
473 : : }
474 : :
475 : 0 : static void __exit alsa_sound_exit(void)
476 : : {
477 : : snd_info_minor_unregister();
478 : 0 : snd_info_done();
479 : 0 : unregister_chrdev(major, "alsa");
480 : 0 : }
481 : :
482 : : subsys_initcall(alsa_sound_init);
483 : : module_exit(alsa_sound_exit);
|
