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