sound.c 11.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
 *  Advanced Linux Sound Architecture
 *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
 *
 *
 *   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
 *
 */

#include <sound/driver.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/time.h>
T
Takashi Iwai 已提交
26
#include <linux/device.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35
#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/info.h>
#include <sound/version.h>
#include <sound/control.h>
#include <sound/initval.h>
#include <linux/kmod.h>
#include <linux/devfs_fs_kernel.h>
36
#include <linux/mutex.h>
L
Linus Torvalds 已提交
37 38 39 40 41

#define SNDRV_OS_MINORS 256

static int major = CONFIG_SND_MAJOR;
int snd_major;
42 43
EXPORT_SYMBOL(snd_major);

L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
static int cards_limit = 1;
static int device_mode = S_IFCHR | S_IRUGO | S_IWUGO;

MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
MODULE_LICENSE("GPL");
module_param(major, int, 0444);
MODULE_PARM_DESC(major, "Major # for sound driver.");
module_param(cards_limit, int, 0444);
MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards.");
#ifdef CONFIG_DEVFS_FS
module_param(device_mode, int, 0444);
MODULE_PARM_DESC(device_mode, "Device file permission mask for devfs.");
#endif
MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);

/* this one holds the actual max. card number currently available.
 * as default, it's identical with cards_limit option.  when more
 * modules are loaded manually, this limit number increases, too.
 */
int snd_ecards_limit;
65
EXPORT_SYMBOL(snd_ecards_limit);
L
Linus Torvalds 已提交
66

67
static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
68
static DEFINE_MUTEX(sound_mutex);
L
Linus Torvalds 已提交
69

70
extern struct class *sound_class;
L
Linus Torvalds 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97


#ifdef CONFIG_KMOD

/**
 * snd_request_card - try to load the card module
 * @card: the card number
 *
 * Tries to load the module "snd-card-X" for the given card number
 * via KMOD.  Returns immediately if already loaded.
 */
void snd_request_card(int card)
{
	int locked;

	if (! current->fs->root)
		return;
	read_lock(&snd_card_rwlock);
	locked = snd_cards_lock & (1 << card);
	read_unlock(&snd_card_rwlock);
	if (locked)
		return;
	if (card < 0 || card >= cards_limit)
		return;
	request_module("snd-card-%i", card);
}

98 99
EXPORT_SYMBOL(snd_request_card);

L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
static void snd_request_other(int minor)
{
	char *str;

	if (! current->fs->root)
		return;
	switch (minor) {
	case SNDRV_MINOR_SEQUENCER:	str = "snd-seq";	break;
	case SNDRV_MINOR_TIMER:		str = "snd-timer";	break;
	default:			return;
	}
	request_module(str);
}

#endif				/* request_module support */

116 117 118 119 120 121 122 123 124 125 126 127 128
/**
 * snd_lookup_minor_data - get user data of a registered device
 * @minor: the minor number
 * @type: device type (SNDRV_DEVICE_TYPE_XXX)
 *
 * Checks that a minor device with the specified type is registered, and returns
 * its user data pointer.
 */
void *snd_lookup_minor_data(unsigned int minor, int type)
{
	struct snd_minor *mreg;
	void *private_data;

129
	if (minor >= ARRAY_SIZE(snd_minors))
130
		return NULL;
131
	mutex_lock(&sound_mutex);
132 133 134 135 136
	mreg = snd_minors[minor];
	if (mreg && mreg->type == type)
		private_data = mreg->private_data;
	else
		private_data = NULL;
137
	mutex_unlock(&sound_mutex);
138 139 140
	return private_data;
}

141 142
EXPORT_SYMBOL(snd_lookup_minor_data);

L
Linus Torvalds 已提交
143 144
static int snd_open(struct inode *inode, struct file *file)
{
145
	unsigned int minor = iminor(inode);
146
	struct snd_minor *mptr = NULL;
147
	const struct file_operations *old_fops;
L
Linus Torvalds 已提交
148 149
	int err = 0;

150
	if (minor >= ARRAY_SIZE(snd_minors))
151 152 153
		return -ENODEV;
	mptr = snd_minors[minor];
	if (mptr == NULL) {
L
Linus Torvalds 已提交
154
#ifdef CONFIG_KMOD
155 156 157 158
		int dev = SNDRV_MINOR_DEVICE(minor);
		if (dev == SNDRV_MINOR_CONTROL) {
			/* /dev/aloadC? */
			int card = SNDRV_MINOR_CARD(minor);
L
Linus Torvalds 已提交
159
			if (snd_cards[card] == NULL)
160 161 162
				snd_request_card(card);
		} else if (dev == SNDRV_MINOR_GLOBAL) {
			/* /dev/aloadSEQ */
L
Linus Torvalds 已提交
163
			snd_request_other(minor);
164 165 166 167 168 169
		}
#ifndef CONFIG_SND_DYNAMIC_MINORS
		/* /dev/snd/{controlC?,seq} */
		mptr = snd_minors[minor];
		if (mptr == NULL)
#endif
L
Linus Torvalds 已提交
170
#endif
171
			return -ENODEV;
L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
	}
	old_fops = file->f_op;
	file->f_op = fops_get(mptr->f_ops);
	if (file->f_op->open)
		err = file->f_op->open(inode, file);
	if (err) {
		fops_put(file->f_op);
		file->f_op = fops_get(old_fops);
	}
	fops_put(old_fops);
	return err;
}

static struct file_operations snd_fops =
{
	.owner =	THIS_MODULE,
	.open =		snd_open
};

191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
#ifdef CONFIG_SND_DYNAMIC_MINORS
static int snd_find_free_minor(void)
{
	int minor;

	for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
		/* skip minors still used statically for autoloading devices */
		if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL ||
		    minor == SNDRV_MINOR_SEQUENCER)
			continue;
		if (!snd_minors[minor])
			return minor;
	}
	return -EBUSY;
}
#else
207
static int snd_kernel_minor(int type, struct snd_card *card, int dev)
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
{
	int minor;

	switch (type) {
	case SNDRV_DEVICE_TYPE_SEQUENCER:
	case SNDRV_DEVICE_TYPE_TIMER:
		minor = type;
		break;
	case SNDRV_DEVICE_TYPE_CONTROL:
		snd_assert(card != NULL, return -EINVAL);
		minor = SNDRV_MINOR(card->number, type);
		break;
	case SNDRV_DEVICE_TYPE_HWDEP:
	case SNDRV_DEVICE_TYPE_RAWMIDI:
	case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
	case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
		snd_assert(card != NULL, return -EINVAL);
		minor = SNDRV_MINOR(card->number, type + dev);
		break;
	default:
		return -EINVAL;
	}
	snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL);
	return minor;
}
233
#endif
L
Linus Torvalds 已提交
234 235 236 237 238 239

/**
 * snd_register_device - Register the ALSA device file for the card
 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
 * @card: the card instance
 * @dev: the device index
240
 * @f_ops: the file operations
241
 * @private_data: user pointer for f_ops->open()
L
Linus Torvalds 已提交
242 243 244 245 246 247 248
 * @name: the device file name
 *
 * Registers an ALSA device file for the given card.
 * The operators have to be set in reg parameter.
 *
 * Retrurns zero if successful, or a negative error code on failure.
 */
249
int snd_register_device(int type, struct snd_card *card, int dev,
250
			const struct file_operations *f_ops, void *private_data,
251
			const char *name)
L
Linus Torvalds 已提交
252
{
253
	int minor;
254
	struct snd_minor *preg;
L
Linus Torvalds 已提交
255 256 257
	struct device *device = NULL;

	snd_assert(name, return -EINVAL);
258
	preg = kmalloc(sizeof(struct snd_minor) + strlen(name) + 1, GFP_KERNEL);
L
Linus Torvalds 已提交
259 260
	if (preg == NULL)
		return -ENOMEM;
261
	preg->type = type;
262
	preg->card = card ? card->number : -1;
L
Linus Torvalds 已提交
263
	preg->device = dev;
264
	preg->f_ops = f_ops;
265
	preg->private_data = private_data;
L
Linus Torvalds 已提交
266
	strcpy(preg->name, name);
267
	mutex_lock(&sound_mutex);
268 269 270 271 272 273 274 275
#ifdef CONFIG_SND_DYNAMIC_MINORS
	minor = snd_find_free_minor();
#else
	minor = snd_kernel_minor(type, card, dev);
	if (minor >= 0 && snd_minors[minor])
		minor = -EBUSY;
#endif
	if (minor < 0) {
276
		mutex_unlock(&sound_mutex);
L
Linus Torvalds 已提交
277
		kfree(preg);
278
		return minor;
L
Linus Torvalds 已提交
279
	}
280 281
	snd_minors[minor] = preg;
	if (type != SNDRV_DEVICE_TYPE_CONTROL || preg->card >= cards_limit)
L
Linus Torvalds 已提交
282
		devfs_mk_cdev(MKDEV(major, minor), S_IFCHR | device_mode, "snd/%s", name);
283
	if (card)
L
Linus Torvalds 已提交
284
		device = card->dev;
285
	class_device_create(sound_class, NULL, MKDEV(major, minor), device, "%s", name);
L
Linus Torvalds 已提交
286

287
	mutex_unlock(&sound_mutex);
L
Linus Torvalds 已提交
288 289 290
	return 0;
}

291 292
EXPORT_SYMBOL(snd_register_device);

L
Linus Torvalds 已提交
293 294 295 296 297 298 299 300 301 302 303
/**
 * snd_unregister_device - unregister the device on the given card
 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
 * @card: the card instance
 * @dev: the device index
 *
 * Unregisters the device file already registered via
 * snd_register_device().
 *
 * Returns zero if sucecessful, or a negative error code on failure
 */
304
int snd_unregister_device(int type, struct snd_card *card, int dev)
L
Linus Torvalds 已提交
305
{
306
	int cardnum, minor;
307
	struct snd_minor *mptr;
L
Linus Torvalds 已提交
308

309
	cardnum = card ? card->number : -1;
310
	mutex_lock(&sound_mutex);
311 312 313 314 315 316 317
	for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
		if ((mptr = snd_minors[minor]) != NULL &&
		    mptr->type == type &&
		    mptr->card == cardnum &&
		    mptr->device == dev)
			break;
	if (minor == ARRAY_SIZE(snd_minors)) {
318
		mutex_unlock(&sound_mutex);
L
Linus Torvalds 已提交
319 320 321
		return -EINVAL;
	}

322 323
	if (mptr->type != SNDRV_DEVICE_TYPE_CONTROL ||
	    mptr->card >= cards_limit)			/* created in sound.c */
L
Linus Torvalds 已提交
324
		devfs_remove("snd/%s", mptr->name);
325
	class_device_destroy(sound_class, MKDEV(major, minor));
L
Linus Torvalds 已提交
326

327
	snd_minors[minor] = NULL;
328
	mutex_unlock(&sound_mutex);
L
Linus Torvalds 已提交
329 330 331 332
	kfree(mptr);
	return 0;
}

333 334
EXPORT_SYMBOL(snd_unregister_device);

335
#ifdef CONFIG_PROC_FS
L
Linus Torvalds 已提交
336 337 338 339
/*
 *  INFO PART
 */

340
static struct snd_info_entry *snd_minor_info_entry = NULL;
L
Linus Torvalds 已提交
341

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
static const char *snd_device_type_name(int type)
{
	switch (type) {
	case SNDRV_DEVICE_TYPE_CONTROL:
		return "control";
	case SNDRV_DEVICE_TYPE_HWDEP:
		return "hardware dependent";
	case SNDRV_DEVICE_TYPE_RAWMIDI:
		return "raw midi";
	case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
		return "digital audio playback";
	case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
		return "digital audio capture";
	case SNDRV_DEVICE_TYPE_SEQUENCER:
		return "sequencer";
	case SNDRV_DEVICE_TYPE_TIMER:
		return "timer";
	default:
		return "?";
	}
}

364
static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
365
{
366
	int minor;
367
	struct snd_minor *mptr;
L
Linus Torvalds 已提交
368

369
	mutex_lock(&sound_mutex);
370 371 372 373 374
	for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
		if (!(mptr = snd_minors[minor]))
			continue;
		if (mptr->card >= 0) {
			if (mptr->device >= 0)
375
				snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
376 377 378
					    minor, mptr->card, mptr->device,
					    snd_device_type_name(mptr->type));
			else
379
				snd_iprintf(buffer, "%3i: [%2i]   : %s\n",
380 381 382
					    minor, mptr->card,
					    snd_device_type_name(mptr->type));
		} else
383
			snd_iprintf(buffer, "%3i:        : %s\n", minor,
384
				    snd_device_type_name(mptr->type));
L
Linus Torvalds 已提交
385
	}
386
	mutex_unlock(&sound_mutex);
L
Linus Torvalds 已提交
387 388 389 390
}

int __init snd_minor_info_init(void)
{
391
	struct snd_info_entry *entry;
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411

	entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
	if (entry) {
		entry->c.text.read_size = PAGE_SIZE;
		entry->c.text.read = snd_minor_info_read;
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	snd_minor_info_entry = entry;
	return 0;
}

int __exit snd_minor_info_done(void)
{
	if (snd_minor_info_entry)
		snd_info_unregister(snd_minor_info_entry);
	return 0;
}
412
#endif /* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

/*
 *  INIT PART
 */

static int __init alsa_sound_init(void)
{
	short controlnum;

	snd_major = major;
	snd_ecards_limit = cards_limit;
	devfs_mk_dir("snd");
	if (register_chrdev(major, "alsa", &snd_fops)) {
		snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
		devfs_remove("snd");
		return -EIO;
	}
	if (snd_info_init() < 0) {
		unregister_chrdev(major, "alsa");
		devfs_remove("snd");
		return -ENOMEM;
	}
	snd_info_minor_register();
	for (controlnum = 0; controlnum < cards_limit; controlnum++)
		devfs_mk_cdev(MKDEV(major, controlnum<<5), S_IFCHR | device_mode, "snd/controlC%d", controlnum);
#ifndef MODULE
	printk(KERN_INFO "Advanced Linux Sound Architecture Driver Version " CONFIG_SND_VERSION CONFIG_SND_DATE ".\n");
#endif
	return 0;
}

static void __exit alsa_sound_exit(void)
{
	short controlnum;

	for (controlnum = 0; controlnum < cards_limit; controlnum++)
		devfs_remove("snd/controlC%d", controlnum);

	snd_info_minor_unregister();
	snd_info_done();
	if (unregister_chrdev(major, "alsa") != 0)
		snd_printk(KERN_ERR "unable to unregister major device number %d\n", major);
	devfs_remove("snd");
}

module_init(alsa_sound_init)
module_exit(alsa_sound_exit)