init.c 20.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *  Initialization routines
3
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 *
 *   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 <linux/init.h>
#include <linux/sched.h>
#include <linux/file.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/ctype.h>
#include <linux/pm.h>
29

L
Linus Torvalds 已提交
30 31 32 33
#include <sound/core.h>
#include <sound/control.h>
#include <sound/info.h>

34 35 36
static DEFINE_SPINLOCK(shutdown_lock);
static LIST_HEAD(shutdown_files);

37
static const struct file_operations snd_shutdown_f_ops;
L
Linus Torvalds 已提交
38

39 40
static unsigned int snd_cards_lock;	/* locked for registering/using */
struct snd_card *snd_cards[SNDRV_CARDS];
41 42
EXPORT_SYMBOL(snd_cards);

43
static DEFINE_MUTEX(snd_card_mutex);
L
Linus Torvalds 已提交
44

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
static char *slots[SNDRV_CARDS];
module_param_array(slots, charp, NULL, 0444);
MODULE_PARM_DESC(slots, "Module names assigned to the slots.");

/* return non-zero if the given index is already reserved for another
 * module via slots option
 */
static int module_slot_mismatch(struct module *module, int idx)
{
#ifdef MODULE
	char *s1, *s2;
	if (!module || !module->name || !slots[idx])
		return 0;
	s1 = slots[idx];
	s2 = module->name;
	/* compare module name strings
	 * hyphens are handled as equivalent with underscore
	 */
	for (;;) {
		char c1 = *s1++;
		char c2 = *s2++;
		if (c1 == '-')
			c1 = '_';
		if (c2 == '-')
			c2 = '_';
		if (c1 != c2)
			return 1;
		if (!c1)
			break;
	}
#endif
	return 0;
}

L
Linus Torvalds 已提交
79
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
80
int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
81
EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
L
Linus Torvalds 已提交
82 83
#endif

84
#ifdef CONFIG_PROC_FS
85 86
static void snd_card_id_read(struct snd_info_entry *entry,
			     struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
87 88 89 90
{
	snd_iprintf(buffer, "%s\n", entry->card->id);
}

91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
static inline int init_info_for_card(struct snd_card *card)
{
	int err;
	struct snd_info_entry *entry;

	if ((err = snd_info_card_register(card)) < 0) {
		snd_printd("unable to create card info\n");
		return err;
	}
	if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
		snd_printd("unable to create card entry\n");
		return err;
	}
	entry->c.text.read = snd_card_id_read;
	if (snd_info_register(entry) < 0) {
		snd_info_free_entry(entry);
		entry = NULL;
	}
	card->proc_id = entry;
	return 0;
}
#else /* !CONFIG_PROC_FS */
#define init_info_for_card(card)
#endif

L
Linus Torvalds 已提交
116 117 118 119 120 121 122 123 124
/**
 *  snd_card_new - create and initialize a soundcard structure
 *  @idx: card index (address) [0 ... (SNDRV_CARDS-1)]
 *  @xid: card identification (ASCII string)
 *  @module: top level module for locking
 *  @extra_size: allocate this extra size after the main soundcard structure
 *
 *  Creates and initializes a soundcard structure.
 *
125
 *  Returns kmallocated snd_card structure. Creates the ALSA control interface
L
Linus Torvalds 已提交
126 127
 *  (which is blocked until snd_card_register function is called).
 */
128
struct snd_card *snd_card_new(int idx, const char *xid,
L
Linus Torvalds 已提交
129 130
			 struct module *module, int extra_size)
{
131
	struct snd_card *card;
L
Linus Torvalds 已提交
132 133 134 135
	int err;

	if (extra_size < 0)
		extra_size = 0;
136
	card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
L
Linus Torvalds 已提交
137 138 139 140 141 142 143 144
	if (card == NULL)
		return NULL;
	if (xid) {
		if (!snd_info_check_reserved_words(xid))
			goto __error;
		strlcpy(card->id, xid, sizeof(card->id));
	}
	err = 0;
145
	mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
146 147 148
	if (idx < 0) {
		int idx2;
		for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
149
			/* idx == -1 == 0xffff means: take any free slot */
L
Linus Torvalds 已提交
150
			if (~snd_cards_lock & idx & 1<<idx2) {
151 152
				if (module_slot_mismatch(module, idx2))
					continue;
L
Linus Torvalds 已提交
153 154 155 156 157
				idx = idx2;
				if (idx >= snd_ecards_limit)
					snd_ecards_limit = idx + 1;
				break;
			}
158 159 160 161 162 163 164 165 166 167 168
	} else {
		 if (idx < snd_ecards_limit) {
			if (snd_cards_lock & (1 << idx))
				err = -EBUSY;	/* invalid */
		} else {
			if (idx < SNDRV_CARDS)
				snd_ecards_limit = idx + 1; /* increase the limit */
			else
				err = -ENODEV;
		}
	}
L
Linus Torvalds 已提交
169
	if (idx < 0 || err < 0) {
170
		mutex_unlock(&snd_card_mutex);
171 172
		snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i), error: %d\n",
			 idx, snd_ecards_limit - 1, err);
L
Linus Torvalds 已提交
173 174 175
		goto __error;
	}
	snd_cards_lock |= 1 << idx;		/* lock it */
176
	mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
177 178 179 180 181 182 183 184 185 186
	card->number = idx;
	card->module = module;
	INIT_LIST_HEAD(&card->devices);
	init_rwsem(&card->controls_rwsem);
	rwlock_init(&card->ctl_files_rwlock);
	INIT_LIST_HEAD(&card->controls);
	INIT_LIST_HEAD(&card->ctl_files);
	spin_lock_init(&card->files_lock);
	init_waitqueue_head(&card->shutdown_sleep);
#ifdef CONFIG_PM
187
	mutex_init(&card->power_lock);
L
Linus Torvalds 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200
	init_waitqueue_head(&card->power_sleep);
#endif
	/* the control interface cannot be accessed from the user space until */
	/* snd_cards_bitmask and snd_cards are set with snd_card_register */
	if ((err = snd_ctl_create(card)) < 0) {
		snd_printd("unable to register control minors\n");
		goto __error;
	}
	if ((err = snd_info_card_create(card)) < 0) {
		snd_printd("unable to create card info\n");
		goto __error_ctl;
	}
	if (extra_size > 0)
201
		card->private_data = (char *)card + sizeof(struct snd_card);
L
Linus Torvalds 已提交
202 203 204 205 206 207 208 209 210
	return card;

      __error_ctl:
	snd_device_free_all(card, SNDRV_DEV_CMD_PRE);
      __error:
	kfree(card);
      	return NULL;
}

211 212
EXPORT_SYMBOL(snd_card_new);

213 214 215 216 217 218 219 220 221 222 223
/* return non-zero if a card is already locked */
int snd_card_locked(int card)
{
	int locked;

	mutex_lock(&snd_card_mutex);
	locked = snd_cards_lock & (1 << card);
	mutex_unlock(&snd_card_mutex);
	return locked;
}

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
{
	return -ENODEV;
}

static ssize_t snd_disconnect_read(struct file *file, char __user *buf,
				   size_t count, loff_t *offset)
{
	return -ENODEV;
}

static ssize_t snd_disconnect_write(struct file *file, const char __user *buf,
				    size_t count, loff_t *offset)
{
	return -ENODEV;
}

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
static int snd_disconnect_release(struct inode *inode, struct file *file)
{
	struct snd_monitor_file *df = NULL, *_df;

	spin_lock(&shutdown_lock);
	list_for_each_entry(_df, &shutdown_files, shutdown_list) {
		if (_df->file == file) {
			df = _df;
			break;
		}
	}
	spin_unlock(&shutdown_lock);

	if (likely(df))
		return df->disconnected_f_op->release(inode, file);

257
	panic("%s(%p, %p) failed!", __func__, inode, file);
258 259
}

L
Linus Torvalds 已提交
260 261 262 263 264
static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
{
	return POLLERR | POLLNVAL;
}

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
static long snd_disconnect_ioctl(struct file *file,
				 unsigned int cmd, unsigned long arg)
{
	return -ENODEV;
}

static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
{
	return -ENODEV;
}

static int snd_disconnect_fasync(int fd, struct file *file, int on)
{
	return -ENODEV;
}

281
static const struct file_operations snd_shutdown_f_ops =
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
{
	.owner = 	THIS_MODULE,
	.llseek =	snd_disconnect_llseek,
	.read = 	snd_disconnect_read,
	.write =	snd_disconnect_write,
	.release =	snd_disconnect_release,
	.poll =		snd_disconnect_poll,
	.unlocked_ioctl = snd_disconnect_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = snd_disconnect_ioctl,
#endif
	.mmap =		snd_disconnect_mmap,
	.fasync =	snd_disconnect_fasync
};

L
Linus Torvalds 已提交
297 298 299 300 301 302 303 304 305 306 307
/**
 *  snd_card_disconnect - disconnect all APIs from the file-operations (user space)
 *  @card: soundcard structure
 *
 *  Disconnects all APIs from the file-operations (user space).
 *
 *  Returns zero, otherwise a negative error code.
 *
 *  Note: The current implementation replaces all active file->f_op with special
 *        dummy file operations (they do nothing except release).
 */
308
int snd_card_disconnect(struct snd_card *card)
L
Linus Torvalds 已提交
309 310 311 312 313 314 315 316 317 318 319 320 321 322
{
	struct snd_monitor_file *mfile;
	struct file *file;
	int err;

	spin_lock(&card->files_lock);
	if (card->shutdown) {
		spin_unlock(&card->files_lock);
		return 0;
	}
	card->shutdown = 1;
	spin_unlock(&card->files_lock);

	/* phase 1: disable fops (user space) operations for ALSA API */
323
	mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
324
	snd_cards[card->number] = NULL;
325
	mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335
	
	/* phase 2: replace file->f_op with special dummy operations */
	
	spin_lock(&card->files_lock);
	mfile = card->files;
	while (mfile) {
		file = mfile->file;

		/* it's critical part, use endless loop */
		/* we have no room to fail */
336
		mfile->disconnected_f_op = mfile->file->f_op;
L
Linus Torvalds 已提交
337

338 339 340
		spin_lock(&shutdown_lock);
		list_add(&mfile->shutdown_list, &shutdown_files);
		spin_unlock(&shutdown_lock);
L
Linus Torvalds 已提交
341

342
		mfile->file->f_op = &snd_shutdown_f_ops;
343
		fops_get(mfile->file->f_op);
L
Linus Torvalds 已提交
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
		
		mfile = mfile->next;
	}
	spin_unlock(&card->files_lock);	

	/* phase 3: notify all connected devices about disconnection */
	/* at this point, they cannot respond to any calls except release() */

#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
	if (snd_mixer_oss_notify_callback)
		snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_DISCONNECT);
#endif

	/* notify all devices that we are disconnected */
	err = snd_device_disconnect_all(card);
	if (err < 0)
		snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number);

362
	snd_info_card_disconnect(card);
L
Linus Torvalds 已提交
363 364 365
	return 0;	
}

366 367
EXPORT_SYMBOL(snd_card_disconnect);

L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375 376 377 378
/**
 *  snd_card_free - frees given soundcard structure
 *  @card: soundcard structure
 *
 *  This function releases the soundcard structure and the all assigned
 *  devices automatically.  That is, you don't have to release the devices
 *  by yourself.
 *
 *  Returns zero. Frees all associated devices and frees the control
 *  interface associated to given soundcard.
 */
379
static int snd_card_do_free(struct snd_card *card)
L
Linus Torvalds 已提交
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
{
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
	if (snd_mixer_oss_notify_callback)
		snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
#endif
	if (snd_device_free_all(card, SNDRV_DEV_CMD_PRE) < 0) {
		snd_printk(KERN_ERR "unable to free all devices (pre)\n");
		/* Fatal, but this situation should never occur */
	}
	if (snd_device_free_all(card, SNDRV_DEV_CMD_NORMAL) < 0) {
		snd_printk(KERN_ERR "unable to free all devices (normal)\n");
		/* Fatal, but this situation should never occur */
	}
	if (snd_device_free_all(card, SNDRV_DEV_CMD_POST) < 0) {
		snd_printk(KERN_ERR "unable to free all devices (post)\n");
		/* Fatal, but this situation should never occur */
	}
	if (card->private_free)
		card->private_free(card);
399
	snd_info_free_entry(card->proc_id);
L
Linus Torvalds 已提交
400 401 402 403
	if (snd_info_card_free(card) < 0) {
		snd_printk(KERN_WARNING "unable to free card info\n");
		/* Not fatal error */
	}
T
Takashi Iwai 已提交
404 405 406 407
#ifndef CONFIG_SYSFS_DEPRECATED
	if (card->card_dev)
		device_unregister(card->card_dev);
#endif
408 409 410 411 412 413 414 415 416
	kfree(card);
	return 0;
}

static int snd_card_free_prepare(struct snd_card *card)
{
	if (card == NULL)
		return -EINVAL;
	(void) snd_card_disconnect(card);
417
	mutex_lock(&snd_card_mutex);
418
	snd_cards[card->number] = NULL;
L
Linus Torvalds 已提交
419
	snd_cards_lock &= ~(1 << card->number);
420
	mutex_unlock(&snd_card_mutex);
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
#ifdef CONFIG_PM
	wake_up(&card->power_sleep);
#endif
	return 0;
}

int snd_card_free_when_closed(struct snd_card *card)
{
	int free_now = 0;
	int ret = snd_card_free_prepare(card);
	if (ret)
		return ret;

	spin_lock(&card->files_lock);
	if (card->files == NULL)
		free_now = 1;
	else
		card->free_on_last_close = 1;
	spin_unlock(&card->files_lock);

	if (free_now)
		snd_card_do_free(card);
	return 0;
}

EXPORT_SYMBOL(snd_card_free_when_closed);

int snd_card_free(struct snd_card *card)
{
	int ret = snd_card_free_prepare(card);
	if (ret)
		return ret;

	/* wait, until all devices are ready for the free operation */
	wait_event(card->shutdown_sleep, card->files == NULL);
	snd_card_do_free(card);
L
Linus Torvalds 已提交
457 458 459
	return 0;
}

460 461
EXPORT_SYMBOL(snd_card_free);

462
static void choose_default_id(struct snd_card *card)
L
Linus Torvalds 已提交
463
{
464
	int i, len, idx_flag = 0, loops = SNDRV_CARDS;
L
Linus Torvalds 已提交
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
	char *id, *spos;
	
	id = spos = card->shortname;	
	while (*id != '\0') {
		if (*id == ' ')
			spos = id + 1;
		id++;
	}
	id = card->id;
	while (*spos != '\0' && !isalnum(*spos))
		spos++;
	if (isdigit(*spos))
		*id++ = isalpha(card->shortname[0]) ? card->shortname[0] : 'D';
	while (*spos != '\0' && (size_t)(id - card->id) < sizeof(card->id) - 1) {
		if (isalnum(*spos))
			*id++ = *spos;
		spos++;
	}
	*id = '\0';

	id = card->id;
	
	if (*id == '\0')
		strcpy(id, "default");

	while (1) {
	      	if (loops-- == 0) {
      			snd_printk(KERN_ERR "unable to choose default card id (%s)\n", id);
      			strcpy(card->id, card->proc_root->name);
      			return;
      		}
	      	if (!snd_info_check_reserved_words(id))
      			goto __change;
		for (i = 0; i < snd_ecards_limit; i++) {
			if (snd_cards[i] && !strcmp(snd_cards[i]->id, id))
				goto __change;
		}
		break;

	      __change:
		len = strlen(id);
506 507 508 509 510 511
		if (idx_flag) {
			if (id[len-1] != '9')
				id[len-1]++;
			else
				id[len-1] = 'A';
		} else if ((size_t)len <= sizeof(card->id) - 3) {
L
Linus Torvalds 已提交
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
			strcat(id, "_1");
			idx_flag++;
		} else {
			spos = id + len - 2;
			if ((size_t)len <= sizeof(card->id) - 2)
				spos++;
			*spos++ = '_';
			*spos++ = '1';
			*spos++ = '\0';
			idx_flag++;
		}
	}
}

/**
 *  snd_card_register - register the soundcard
 *  @card: soundcard structure
 *
 *  This function registers all the devices assigned to the soundcard.
 *  Until calling this, the ALSA control interface is blocked from the
 *  external accesses.  Thus, you should call this function at the end
 *  of the initialization of the card.
 *
 *  Returns zero otherwise a negative error code if the registrain failed.
 */
537
int snd_card_register(struct snd_card *card)
L
Linus Torvalds 已提交
538 539 540
{
	int err;

541
	snd_assert(card != NULL, return -EINVAL);
T
Takashi Iwai 已提交
542 543 544 545 546 547
#ifndef CONFIG_SYSFS_DEPRECATED
	if (!card->card_dev) {
		card->card_dev = device_create(sound_class, card->dev, 0,
					       "card%i", card->number);
		if (IS_ERR(card->card_dev))
			card->card_dev = NULL;
548
	}
T
Takashi Iwai 已提交
549
#endif
L
Linus Torvalds 已提交
550 551
	if ((err = snd_device_register_all(card)) < 0)
		return err;
552
	mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
553 554
	if (snd_cards[card->number]) {
		/* already registered */
555
		mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
556 557 558 559 560
		return 0;
	}
	if (card->id[0] == '\0')
		choose_default_id(card);
	snd_cards[card->number] = card;
561
	mutex_unlock(&snd_card_mutex);
562
	init_info_for_card(card);
L
Linus Torvalds 已提交
563 564 565 566 567 568 569
#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
	if (snd_mixer_oss_notify_callback)
		snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
#endif
	return 0;
}

570 571
EXPORT_SYMBOL(snd_card_register);

572
#ifdef CONFIG_PROC_FS
573
static struct snd_info_entry *snd_card_info_entry;
L
Linus Torvalds 已提交
574

T
Takashi Iwai 已提交
575 576
static void snd_card_info_read(struct snd_info_entry *entry,
			       struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
577 578
{
	int idx, count;
579
	struct snd_card *card;
L
Linus Torvalds 已提交
580 581

	for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
582
		mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
583 584
		if ((card = snd_cards[idx]) != NULL) {
			count++;
585
			snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
L
Linus Torvalds 已提交
586 587 588 589
					idx,
					card->id,
					card->driver,
					card->shortname);
590
			snd_iprintf(buffer, "                      %s\n",
L
Linus Torvalds 已提交
591 592
					card->longname);
		}
593
		mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
594 595 596 597 598
	}
	if (!count)
		snd_iprintf(buffer, "--- no soundcards ---\n");
}

599
#ifdef CONFIG_SND_OSSEMUL
L
Linus Torvalds 已提交
600

601
void snd_card_info_read_oss(struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
602 603
{
	int idx, count;
604
	struct snd_card *card;
L
Linus Torvalds 已提交
605 606

	for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
607
		mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
608 609 610 611
		if ((card = snd_cards[idx]) != NULL) {
			count++;
			snd_iprintf(buffer, "%s\n", card->longname);
		}
612
		mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
613 614 615 616 617 618 619 620 621
	}
	if (!count) {
		snd_iprintf(buffer, "--- no soundcards ---\n");
	}
}

#endif

#ifdef MODULE
622 623 624
static struct snd_info_entry *snd_card_module_info_entry;
static void snd_card_module_info_read(struct snd_info_entry *entry,
				      struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
625 626
{
	int idx;
627
	struct snd_card *card;
L
Linus Torvalds 已提交
628 629

	for (idx = 0; idx < SNDRV_CARDS; idx++) {
630
		mutex_lock(&snd_card_mutex);
L
Linus Torvalds 已提交
631
		if ((card = snd_cards[idx]) != NULL)
632 633
			snd_iprintf(buffer, "%2i %s\n",
				    idx, card->module->name);
634
		mutex_unlock(&snd_card_mutex);
L
Linus Torvalds 已提交
635 636 637 638 639 640
	}
}
#endif

int __init snd_card_info_init(void)
{
641
	struct snd_info_entry *entry;
L
Linus Torvalds 已提交
642 643

	entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
644 645
	if (! entry)
		return -ENOMEM;
L
Linus Torvalds 已提交
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
	entry->c.text.read = snd_card_info_read;
	if (snd_info_register(entry) < 0) {
		snd_info_free_entry(entry);
		return -ENOMEM;
	}
	snd_card_info_entry = entry;

#ifdef MODULE
	entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
	if (entry) {
		entry->c.text.read = snd_card_module_info_read;
		if (snd_info_register(entry) < 0)
			snd_info_free_entry(entry);
		else
			snd_card_module_info_entry = entry;
	}
#endif

	return 0;
}

int __exit snd_card_info_done(void)
{
669
	snd_info_free_entry(snd_card_info_entry);
L
Linus Torvalds 已提交
670
#ifdef MODULE
671
	snd_info_free_entry(snd_card_module_info_entry);
L
Linus Torvalds 已提交
672 673 674 675
#endif
	return 0;
}

676 677
#endif /* CONFIG_PROC_FS */

L
Linus Torvalds 已提交
678 679 680 681 682 683 684 685 686 687 688
/**
 *  snd_component_add - add a component string
 *  @card: soundcard structure
 *  @component: the component id string
 *
 *  This function adds the component id string to the supported list.
 *  The component can be referred from the alsa-lib.
 *
 *  Returns zero otherwise a negative error code.
 */
  
689
int snd_component_add(struct snd_card *card, const char *component)
L
Linus Torvalds 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
{
	char *ptr;
	int len = strlen(component);

	ptr = strstr(card->components, component);
	if (ptr != NULL) {
		if (ptr[len] == '\0' || ptr[len] == ' ')	/* already there */
			return 1;
	}
	if (strlen(card->components) + 1 + len + 1 > sizeof(card->components)) {
		snd_BUG();
		return -ENOMEM;
	}
	if (card->components[0] != '\0')
		strcat(card->components, " ");
	strcat(card->components, component);
	return 0;
}

709 710
EXPORT_SYMBOL(snd_component_add);

L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718 719 720 721
/**
 *  snd_card_file_add - add the file to the file list of the card
 *  @card: soundcard structure
 *  @file: file pointer
 *
 *  This function adds the file to the file linked-list of the card.
 *  This linked-list is used to keep tracking the connection state,
 *  and to avoid the release of busy resources by hotplug.
 *
 *  Returns zero or a negative error code.
 */
722
int snd_card_file_add(struct snd_card *card, struct file *file)
L
Linus Torvalds 已提交
723 724 725 726 727 728 729
{
	struct snd_monitor_file *mfile;

	mfile = kmalloc(sizeof(*mfile), GFP_KERNEL);
	if (mfile == NULL)
		return -ENOMEM;
	mfile->file = file;
730
	mfile->disconnected_f_op = NULL;
L
Linus Torvalds 已提交
731 732 733 734 735 736 737 738 739 740 741 742 743
	mfile->next = NULL;
	spin_lock(&card->files_lock);
	if (card->shutdown) {
		spin_unlock(&card->files_lock);
		kfree(mfile);
		return -ENODEV;
	}
	mfile->next = card->files;
	card->files = mfile;
	spin_unlock(&card->files_lock);
	return 0;
}

744 745
EXPORT_SYMBOL(snd_card_file_add);

L
Linus Torvalds 已提交
746 747 748 749 750 751 752
/**
 *  snd_card_file_remove - remove the file from the file list
 *  @card: soundcard structure
 *  @file: file pointer
 *
 *  This function removes the file formerly added to the card via
 *  snd_card_file_add() function.
753 754 755
 *  If all files are removed and snd_card_free_when_closed() was
 *  called beforehand, it processes the pending release of
 *  resources.
L
Linus Torvalds 已提交
756 757 758
 *
 *  Returns zero or a negative error code.
 */
759
int snd_card_file_remove(struct snd_card *card, struct file *file)
L
Linus Torvalds 已提交
760 761
{
	struct snd_monitor_file *mfile, *pfile = NULL;
762
	int last_close = 0;
L
Linus Torvalds 已提交
763 764 765 766 767 768 769 770 771 772 773 774 775 776

	spin_lock(&card->files_lock);
	mfile = card->files;
	while (mfile) {
		if (mfile->file == file) {
			if (pfile)
				pfile->next = mfile->next;
			else
				card->files = mfile->next;
			break;
		}
		pfile = mfile;
		mfile = mfile->next;
	}
777 778 779 780 781 782
	if (mfile && mfile->disconnected_f_op) {
		fops_put(mfile->disconnected_f_op);
		spin_lock(&shutdown_lock);
		list_del(&mfile->shutdown_list);
		spin_unlock(&shutdown_lock);
	}
L
Linus Torvalds 已提交
783
	if (card->files == NULL)
784 785 786
		last_close = 1;
	spin_unlock(&card->files_lock);
	if (last_close) {
L
Linus Torvalds 已提交
787
		wake_up(&card->shutdown_sleep);
788 789 790
		if (card->free_on_last_close)
			snd_card_do_free(card);
	}
L
Linus Torvalds 已提交
791 792 793 794 795 796 797 798
	if (!mfile) {
		snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
		return -ENOENT;
	}
	kfree(mfile);
	return 0;
}

799 800
EXPORT_SYMBOL(snd_card_file_remove);

L
Linus Torvalds 已提交
801 802 803 804 805 806 807 808 809 810
#ifdef CONFIG_PM
/**
 *  snd_power_wait - wait until the power-state is changed.
 *  @card: soundcard structure
 *  @power_state: expected power state
 *
 *  Waits until the power-state is changed.
 *
 *  Note: the power lock must be active before call.
 */
811
int snd_power_wait(struct snd_card *card, unsigned int power_state)
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
{
	wait_queue_t wait;
	int result = 0;

	/* fastpath */
	if (snd_power_get_state(card) == power_state)
		return 0;
	init_waitqueue_entry(&wait, current);
	add_wait_queue(&card->power_sleep, &wait);
	while (1) {
		if (card->shutdown) {
			result = -ENODEV;
			break;
		}
		if (snd_power_get_state(card) == power_state)
			break;
		set_current_state(TASK_UNINTERRUPTIBLE);
		snd_power_unlock(card);
		schedule_timeout(30 * HZ);
		snd_power_lock(card);
	}
	remove_wait_queue(&card->power_sleep, &wait);
	return result;
}

837
EXPORT_SYMBOL(snd_power_wait);
L
Linus Torvalds 已提交
838
#endif /* CONFIG_PM */