pcm.c 32.1 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
/*
 *  Digital Audio (PCM) abstract layer
 *  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>
26
#include <linux/mutex.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35 36
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/pcm.h>
#include <sound/control.h>
#include <sound/info.h>

MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Abramo Bagnara <abramo@alsa-project.org>");
MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
MODULE_LICENSE("GPL");

37
static LIST_HEAD(snd_pcm_devices);
L
Linus Torvalds 已提交
38
static LIST_HEAD(snd_pcm_notify_list);
39
static DEFINE_MUTEX(register_mutex);
L
Linus Torvalds 已提交
40

T
Takashi Iwai 已提交
41 42 43 44 45
static int snd_pcm_free(struct snd_pcm *pcm);
static int snd_pcm_dev_free(struct snd_device *device);
static int snd_pcm_dev_register(struct snd_device *device);
static int snd_pcm_dev_disconnect(struct snd_device *device);
static int snd_pcm_dev_unregister(struct snd_device *device);
L
Linus Torvalds 已提交
46

47 48 49 50 51 52 53 54 55 56 57 58 59
static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device)
{
	struct list_head *p;
	struct snd_pcm *pcm;

	list_for_each(p, &snd_pcm_devices) {
		pcm = list_entry(p, struct snd_pcm, list);
		if (pcm->card == card && pcm->device == device)
			return pcm;
	}
	return NULL;
}

T
Takashi Iwai 已提交
60 61
static int snd_pcm_control_ioctl(struct snd_card *card,
				 struct snd_ctl_file *control,
L
Linus Torvalds 已提交
62 63 64 65 66 67 68 69 70
				 unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
		{
			int device;

			if (get_user(device, (int __user *)arg))
				return -EFAULT;
71
			mutex_lock(&register_mutex);
L
Linus Torvalds 已提交
72 73
			device = device < 0 ? 0 : device + 1;
			while (device < SNDRV_PCM_DEVICES) {
74
				if (snd_pcm_search(card, device))
L
Linus Torvalds 已提交
75 76 77 78 79
					break;
				device++;
			}
			if (device == SNDRV_PCM_DEVICES)
				device = -1;
80
			mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
81 82 83 84 85 86
			if (put_user(device, (int __user *)arg))
				return -EFAULT;
			return 0;
		}
	case SNDRV_CTL_IOCTL_PCM_INFO:
		{
T
Takashi Iwai 已提交
87
			struct snd_pcm_info __user *info;
L
Linus Torvalds 已提交
88
			unsigned int device, subdevice;
T
Takashi Iwai 已提交
89 90 91 92
			int stream;
			struct snd_pcm *pcm;
			struct snd_pcm_str *pstr;
			struct snd_pcm_substream *substream;
93 94
			int err;

T
Takashi Iwai 已提交
95
			info = (struct snd_pcm_info __user *)arg;
L
Linus Torvalds 已提交
96 97 98 99 100 101 102 103
			if (get_user(device, &info->device))
				return -EFAULT;
			if (get_user(stream, &info->stream))
				return -EFAULT;
			if (stream < 0 || stream > 1)
				return -EINVAL;
			if (get_user(subdevice, &info->subdevice))
				return -EFAULT;
104
			mutex_lock(&register_mutex);
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
			pcm = snd_pcm_search(card, device);
			if (pcm == NULL) {
				err = -ENXIO;
				goto _error;
			}
			pstr = &pcm->streams[stream];
			if (pstr->substream_count == 0) {
				err = -ENOENT;
				goto _error;
			}
			if (subdevice >= pstr->substream_count) {
				err = -ENXIO;
				goto _error;
			}
			for (substream = pstr->substream; substream;
			     substream = substream->next)
L
Linus Torvalds 已提交
121 122
				if (substream->number == (int)subdevice)
					break;
123 124 125 126 127 128
			if (substream == NULL) {
				err = -ENXIO;
				goto _error;
			}
			err = snd_pcm_info_user(substream, info);
		_error:
129
			mutex_unlock(&register_mutex);
130
			return err;
L
Linus Torvalds 已提交
131 132 133 134 135 136 137 138 139 140 141 142 143
		}
	case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
		{
			int val;
			
			if (get_user(val, (int __user *)arg))
				return -EFAULT;
			control->prefer_pcm_subdevice = val;
			return 0;
		}
	}
	return -ENOIOCTLCMD;
}
144 145 146

#if defined(CONFIG_PROC_FS) && defined(CONFIG_SND_VERBOSE_PROCFS)

L
Linus Torvalds 已提交
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
#define STATE(v) [SNDRV_PCM_STATE_##v] = #v
#define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
#define READY(v) [SNDRV_PCM_READY_##v] = #v
#define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
#define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
#define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
#define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
#define START(v) [SNDRV_PCM_START_##v] = #v
#define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
#define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v 

static char *snd_pcm_format_names[] = {
	FORMAT(S8),
	FORMAT(U8),
	FORMAT(S16_LE),
	FORMAT(S16_BE),
	FORMAT(U16_LE),
	FORMAT(U16_BE),
	FORMAT(S24_LE),
	FORMAT(S24_BE),
	FORMAT(U24_LE),
	FORMAT(U24_BE),
	FORMAT(S32_LE),
	FORMAT(S32_BE),
	FORMAT(U32_LE),
	FORMAT(U32_BE),
	FORMAT(FLOAT_LE),
	FORMAT(FLOAT_BE),
	FORMAT(FLOAT64_LE),
	FORMAT(FLOAT64_BE),
	FORMAT(IEC958_SUBFRAME_LE),
	FORMAT(IEC958_SUBFRAME_BE),
	FORMAT(MU_LAW),
	FORMAT(A_LAW),
	FORMAT(IMA_ADPCM),
	FORMAT(MPEG),
	FORMAT(GSM),
	FORMAT(SPECIAL),
	FORMAT(S24_3LE),
	FORMAT(S24_3BE),
	FORMAT(U24_3LE),
	FORMAT(U24_3BE),
	FORMAT(S20_3LE),
	FORMAT(S20_3BE),
	FORMAT(U20_3LE),
	FORMAT(U20_3BE),
	FORMAT(S18_3LE),
	FORMAT(S18_3BE),
	FORMAT(U18_3LE),
	FORMAT(U18_3BE),
};

199
static const char *snd_pcm_format_name(snd_pcm_format_t format)
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
{
	return snd_pcm_format_names[format];
}

static char *snd_pcm_stream_names[] = {
	STREAM(PLAYBACK),
	STREAM(CAPTURE),
};

static char *snd_pcm_state_names[] = {
	STATE(OPEN),
	STATE(SETUP),
	STATE(PREPARED),
	STATE(RUNNING),
	STATE(XRUN),
	STATE(DRAINING),
	STATE(PAUSED),
	STATE(SUSPENDED),
};

static char *snd_pcm_access_names[] = {
	ACCESS(MMAP_INTERLEAVED), 
	ACCESS(MMAP_NONINTERLEAVED),
	ACCESS(MMAP_COMPLEX),
	ACCESS(RW_INTERLEAVED),
	ACCESS(RW_NONINTERLEAVED),
};

L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235 236
static char *snd_pcm_subformat_names[] = {
	SUBFORMAT(STD), 
};

static char *snd_pcm_tstamp_mode_names[] = {
	TSTAMP(NONE),
	TSTAMP(MMAP),
};

T
Takashi Iwai 已提交
237
static const char *snd_pcm_stream_name(int stream)
L
Linus Torvalds 已提交
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
{
	snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL);
	return snd_pcm_stream_names[stream];
}

static const char *snd_pcm_access_name(snd_pcm_access_t access)
{
	return snd_pcm_access_names[access];
}

static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
{
	return snd_pcm_subformat_names[subformat];
}

T
Takashi Iwai 已提交
253
static const char *snd_pcm_tstamp_mode_name(int mode)
L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261 262 263 264 265
{
	snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL);
	return snd_pcm_tstamp_mode_names[mode];
}

static const char *snd_pcm_state_name(snd_pcm_state_t state)
{
	return snd_pcm_state_names[state];
}

#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
#include <linux/soundcard.h>
266

L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
static const char *snd_pcm_oss_format_name(int format)
{
	switch (format) {
	case AFMT_MU_LAW:
		return "MU_LAW";
	case AFMT_A_LAW:
		return "A_LAW";
	case AFMT_IMA_ADPCM:
		return "IMA_ADPCM";
	case AFMT_U8:
		return "U8";
	case AFMT_S16_LE:
		return "S16_LE";
	case AFMT_S16_BE:
		return "S16_BE";
	case AFMT_S8:
		return "S8";
	case AFMT_U16_LE:
		return "U16_LE";
	case AFMT_U16_BE:
		return "U16_BE";
	case AFMT_MPEG:
		return "MPEG";
	default:
		return "unknown";
	}
}
#endif

T
Takashi Iwai 已提交
296 297
static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
				   struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
298
{
T
Takashi Iwai 已提交
299
	struct snd_pcm_info *info;
L
Linus Torvalds 已提交
300 301
	int err;

302 303
	if (! substream)
		return;
L
Linus Torvalds 已提交
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330

	info = kmalloc(sizeof(*info), GFP_KERNEL);
	if (! info) {
		printk(KERN_DEBUG "snd_pcm_proc_info_read: cannot malloc\n");
		return;
	}

	err = snd_pcm_info(substream, info);
	if (err < 0) {
		snd_iprintf(buffer, "error %d\n", err);
		kfree(info);
		return;
	}
	snd_iprintf(buffer, "card: %d\n", info->card);
	snd_iprintf(buffer, "device: %d\n", info->device);
	snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
	snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
	snd_iprintf(buffer, "id: %s\n", info->id);
	snd_iprintf(buffer, "name: %s\n", info->name);
	snd_iprintf(buffer, "subname: %s\n", info->subname);
	snd_iprintf(buffer, "class: %d\n", info->dev_class);
	snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
	snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
	snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
	kfree(info);
}

T
Takashi Iwai 已提交
331 332
static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
					  struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
333
{
T
Takashi Iwai 已提交
334 335
	snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
			       buffer);
L
Linus Torvalds 已提交
336 337
}

T
Takashi Iwai 已提交
338 339
static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
					     struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
340
{
T
Takashi Iwai 已提交
341 342
	snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
			       buffer);
L
Linus Torvalds 已提交
343 344
}

T
Takashi Iwai 已提交
345 346
static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
						  struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
347
{
T
Takashi Iwai 已提交
348 349
	struct snd_pcm_substream *substream = entry->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
	if (!runtime) {
		snd_iprintf(buffer, "closed\n");
		return;
	}
	snd_pcm_stream_lock_irq(substream);
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		snd_iprintf(buffer, "no setup\n");
		snd_pcm_stream_unlock_irq(substream);
		return;
	}
	snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
	snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
	snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
	snd_iprintf(buffer, "channels: %u\n", runtime->channels);	
	snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den);	
	snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);	
	snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);	
	snd_iprintf(buffer, "tick_time: %u\n", runtime->tick_time);
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	if (substream->oss.oss) {
		snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
		snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);	
		snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate);
		snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes);
		snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods);
		snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
	}
#endif
	snd_pcm_stream_unlock_irq(substream);
}

T
Takashi Iwai 已提交
381 382
static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
						  struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
383
{
T
Takashi Iwai 已提交
384 385
	struct snd_pcm_substream *substream = entry->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
L
Linus Torvalds 已提交
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
	if (!runtime) {
		snd_iprintf(buffer, "closed\n");
		return;
	}
	snd_pcm_stream_lock_irq(substream);
	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		snd_iprintf(buffer, "no setup\n");
		snd_pcm_stream_unlock_irq(substream);
		return;
	}
	snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
	snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
	snd_iprintf(buffer, "sleep_min: %u\n", runtime->sleep_min);
	snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
	snd_iprintf(buffer, "xfer_align: %lu\n", runtime->xfer_align);
	snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
	snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
	snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
	snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
	snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
	snd_pcm_stream_unlock_irq(substream);
}

T
Takashi Iwai 已提交
409 410
static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
					       struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
411
{
T
Takashi Iwai 已提交
412 413 414
	struct snd_pcm_substream *substream = entry->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_pcm_status status;
L
Linus Torvalds 已提交
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
	int err;
	if (!runtime) {
		snd_iprintf(buffer, "closed\n");
		return;
	}
	memset(&status, 0, sizeof(status));
	err = snd_pcm_status(substream, &status);
	if (err < 0) {
		snd_iprintf(buffer, "error %d\n", err);
		return;
	}
	snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
	snd_iprintf(buffer, "trigger_time: %ld.%09ld\n",
		status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec);
	snd_iprintf(buffer, "tstamp      : %ld.%09ld\n",
		status.tstamp.tv_sec, status.tstamp.tv_nsec);
	snd_iprintf(buffer, "delay       : %ld\n", status.delay);
	snd_iprintf(buffer, "avail       : %ld\n", status.avail);
	snd_iprintf(buffer, "avail_max   : %ld\n", status.avail_max);
	snd_iprintf(buffer, "-----\n");
	snd_iprintf(buffer, "hw_ptr      : %ld\n", runtime->status->hw_ptr);
	snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
}

439
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
T
Takashi Iwai 已提交
440 441
static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
				    struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
442
{
T
Takashi Iwai 已提交
443
	struct snd_pcm_str *pstr = entry->private_data;
L
Linus Torvalds 已提交
444 445 446
	snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
}

T
Takashi Iwai 已提交
447 448
static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
				     struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
449
{
T
Takashi Iwai 已提交
450
	struct snd_pcm_str *pstr = entry->private_data;
L
Linus Torvalds 已提交
451 452 453 454 455 456
	char line[64];
	if (!snd_info_get_line(buffer, line, sizeof(line)))
		pstr->xrun_debug = simple_strtoul(line, NULL, 10);
}
#endif

T
Takashi Iwai 已提交
457
static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
L
Linus Torvalds 已提交
458
{
T
Takashi Iwai 已提交
459 460
	struct snd_pcm *pcm = pstr->pcm;
	struct snd_info_entry *entry;
L
Linus Torvalds 已提交
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
	char name[16];

	sprintf(name, "pcm%i%c", pcm->device, 
		pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
	if ((entry = snd_info_create_card_entry(pcm->card, name, pcm->card->proc_root)) == NULL)
		return -ENOMEM;
	entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
	if (snd_info_register(entry) < 0) {
		snd_info_free_entry(entry);
		return -ENOMEM;
	}
	pstr->proc_root = entry;

	if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
		snd_info_set_text_ops(entry, pstr, 256, snd_pcm_stream_proc_info_read);
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	pstr->proc_info_entry = entry;

483
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
T
Takashi Iwai 已提交
484 485
	if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
						pstr->proc_root)) != NULL) {
L
Linus Torvalds 已提交
486 487 488 489
		entry->c.text.read_size = 64;
		entry->c.text.read = snd_pcm_xrun_debug_read;
		entry->c.text.write_size = 64;
		entry->c.text.write = snd_pcm_xrun_debug_write;
490
		entry->mode |= S_IWUSR;
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500 501
		entry->private_data = pstr;
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	pstr->proc_xrun_debug_entry = entry;
#endif
	return 0;
}

T
Takashi Iwai 已提交
502
static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
L
Linus Torvalds 已提交
503
{
504
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
L
Linus Torvalds 已提交
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
	if (pstr->proc_xrun_debug_entry) {
		snd_info_unregister(pstr->proc_xrun_debug_entry);
		pstr->proc_xrun_debug_entry = NULL;
	}
#endif
	if (pstr->proc_info_entry) {
		snd_info_unregister(pstr->proc_info_entry);
		pstr->proc_info_entry = NULL;
	}
	if (pstr->proc_root) {
		snd_info_unregister(pstr->proc_root);
		pstr->proc_root = NULL;
	}
	return 0;
}

T
Takashi Iwai 已提交
521
static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
522
{
T
Takashi Iwai 已提交
523 524
	struct snd_info_entry *entry;
	struct snd_card *card;
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
	char name[16];

	card = substream->pcm->card;

	sprintf(name, "sub%i", substream->number);
	if ((entry = snd_info_create_card_entry(card, name, substream->pstr->proc_root)) == NULL)
		return -ENOMEM;
	entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
	if (snd_info_register(entry) < 0) {
		snd_info_free_entry(entry);
		return -ENOMEM;
	}
	substream->proc_root = entry;

	if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
		snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_info_read);
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	substream->proc_info_entry = entry;

	if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
		snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_hw_params_read);
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	substream->proc_hw_params_entry = entry;

	if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
		snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_sw_params_read);
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	substream->proc_sw_params_entry = entry;

	if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
		snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_status_read);
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	substream->proc_status_entry = entry;

	return 0;
}
		
T
Takashi Iwai 已提交
578
static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
{
	if (substream->proc_info_entry) {
		snd_info_unregister(substream->proc_info_entry);
		substream->proc_info_entry = NULL;
	}
	if (substream->proc_hw_params_entry) {
		snd_info_unregister(substream->proc_hw_params_entry);
		substream->proc_hw_params_entry = NULL;
	}
	if (substream->proc_sw_params_entry) {
		snd_info_unregister(substream->proc_sw_params_entry);
		substream->proc_sw_params_entry = NULL;
	}
	if (substream->proc_status_entry) {
		snd_info_unregister(substream->proc_status_entry);
		substream->proc_status_entry = NULL;
	}
	if (substream->proc_root) {
		snd_info_unregister(substream->proc_root);
		substream->proc_root = NULL;
	}
	return 0;
}
602 603 604 605 606 607
#else /* !CONFIG_PROC_FS */
static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; }
#endif /* CONFIG_PROC_FS */
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615 616 617 618 619 620 621

/**
 * snd_pcm_new_stream - create a new PCM stream
 * @pcm: the pcm instance
 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
 * @substream_count: the number of substreams
 *
 * Creates a new stream for the pcm.
 * The corresponding stream on the pcm must have been empty before
 * calling this, i.e. zero must be given to the argument of
 * snd_pcm_new().
 *
 * Returns zero if successful, or a negative error code on failure.
 */
T
Takashi Iwai 已提交
622
int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
L
Linus Torvalds 已提交
623 624
{
	int idx, err;
T
Takashi Iwai 已提交
625 626
	struct snd_pcm_str *pstr = &pcm->streams[stream];
	struct snd_pcm_substream *substream, *prev;
L
Linus Torvalds 已提交
627 628

#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
629
	mutex_init(&pstr->oss.setup_mutex);
L
Linus Torvalds 已提交
630 631 632 633 634 635
#endif
	pstr->stream = stream;
	pstr->pcm = pcm;
	pstr->substream_count = substream_count;
	if (substream_count > 0) {
		err = snd_pcm_stream_proc_init(pstr);
T
Takashi Iwai 已提交
636 637
		if (err < 0) {
			snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
L
Linus Torvalds 已提交
638
			return err;
T
Takashi Iwai 已提交
639
		}
L
Linus Torvalds 已提交
640 641 642
	}
	prev = NULL;
	for (idx = 0, prev = NULL; idx < substream_count; idx++) {
643
		substream = kzalloc(sizeof(*substream), GFP_KERNEL);
T
Takashi Iwai 已提交
644 645
		if (substream == NULL) {
			snd_printk(KERN_ERR "Cannot allocate PCM substream\n");
L
Linus Torvalds 已提交
646
			return -ENOMEM;
T
Takashi Iwai 已提交
647
		}
L
Linus Torvalds 已提交
648 649 650 651 652 653 654 655 656 657 658 659
		substream->pcm = pcm;
		substream->pstr = pstr;
		substream->number = idx;
		substream->stream = stream;
		sprintf(substream->name, "subdevice #%i", idx);
		substream->buffer_bytes_max = UINT_MAX;
		if (prev == NULL)
			pstr->substream = substream;
		else
			prev->next = substream;
		err = snd_pcm_substream_proc_init(substream);
		if (err < 0) {
T
Takashi Iwai 已提交
660
			snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
			kfree(substream);
			return err;
		}
		substream->group = &substream->self_group;
		spin_lock_init(&substream->self_group.lock);
		INIT_LIST_HEAD(&substream->self_group.substreams);
		list_add_tail(&substream->link_list, &substream->self_group.substreams);
		spin_lock_init(&substream->timer_lock);
		prev = substream;
	}
	return 0;
}				

/**
 * snd_pcm_new - create a new PCM instance
 * @card: the card instance
 * @id: the id string
 * @device: the device index (zero based)
 * @playback_count: the number of substreams for playback
 * @capture_count: the number of substreams for capture
 * @rpcm: the pointer to store the new pcm instance
 *
 * Creates a new PCM instance.
 *
 * The pcm operators have to be set afterwards to the new instance
 * via snd_pcm_set_ops().
 *
 * Returns zero if successful, or a negative error code on failure.
 */
T
Takashi Iwai 已提交
690
int snd_pcm_new(struct snd_card *card, char *id, int device,
L
Linus Torvalds 已提交
691
		int playback_count, int capture_count,
T
Takashi Iwai 已提交
692
	        struct snd_pcm ** rpcm)
L
Linus Torvalds 已提交
693
{
T
Takashi Iwai 已提交
694
	struct snd_pcm *pcm;
L
Linus Torvalds 已提交
695
	int err;
T
Takashi Iwai 已提交
696
	static struct snd_device_ops ops = {
L
Linus Torvalds 已提交
697 698 699 700 701 702 703 704 705
		.dev_free = snd_pcm_dev_free,
		.dev_register =	snd_pcm_dev_register,
		.dev_disconnect = snd_pcm_dev_disconnect,
		.dev_unregister = snd_pcm_dev_unregister
	};

	snd_assert(rpcm != NULL, return -EINVAL);
	*rpcm = NULL;
	snd_assert(card != NULL, return -ENXIO);
706
	pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
T
Takashi Iwai 已提交
707 708
	if (pcm == NULL) {
		snd_printk(KERN_ERR "Cannot allocate PCM\n");
L
Linus Torvalds 已提交
709
		return -ENOMEM;
T
Takashi Iwai 已提交
710
	}
L
Linus Torvalds 已提交
711 712
	pcm->card = card;
	pcm->device = device;
T
Takashi Iwai 已提交
713
	if (id)
L
Linus Torvalds 已提交
714 715 716 717 718 719 720 721 722
		strlcpy(pcm->id, id, sizeof(pcm->id));
	if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {
		snd_pcm_free(pcm);
		return err;
	}
	if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) {
		snd_pcm_free(pcm);
		return err;
	}
723
	mutex_init(&pcm->open_mutex);
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732
	init_waitqueue_head(&pcm->open_wait);
	if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {
		snd_pcm_free(pcm);
		return err;
	}
	*rpcm = pcm;
	return 0;
}

T
Takashi Iwai 已提交
733
static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
L
Linus Torvalds 已提交
734
{
T
Takashi Iwai 已提交
735
	struct snd_pcm_substream *substream, *substream_next;
L
Linus Torvalds 已提交
736
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
T
Takashi Iwai 已提交
737
	struct snd_pcm_oss_setup *setup, *setupn;
L
Linus Torvalds 已提交
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
#endif
	substream = pstr->substream;
	while (substream) {
		substream_next = substream->next;
		snd_pcm_substream_proc_done(substream);
		kfree(substream);
		substream = substream_next;
	}
	snd_pcm_stream_proc_done(pstr);
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
	for (setup = pstr->oss.setup_list; setup; setup = setupn) {
		setupn = setup->next;
		kfree(setup->task_name);
		kfree(setup);
	}
#endif
}

T
Takashi Iwai 已提交
756
static int snd_pcm_free(struct snd_pcm *pcm)
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765 766 767
{
	snd_assert(pcm != NULL, return -ENXIO);
	if (pcm->private_free)
		pcm->private_free(pcm);
	snd_pcm_lib_preallocate_free_for_all(pcm);
	snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
	snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
	kfree(pcm);
	return 0;
}

T
Takashi Iwai 已提交
768
static int snd_pcm_dev_free(struct snd_device *device)
L
Linus Torvalds 已提交
769
{
T
Takashi Iwai 已提交
770
	struct snd_pcm *pcm = device->device_data;
L
Linus Torvalds 已提交
771 772 773 774 775
	return snd_pcm_free(pcm);
}

static void snd_pcm_tick_timer_func(unsigned long data)
{
T
Takashi Iwai 已提交
776
	struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data;
L
Linus Torvalds 已提交
777 778 779
	snd_pcm_tick_elapsed(substream);
}

780 781 782
int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
			     struct file *file,
			     struct snd_pcm_substream **rsubstream)
L
Linus Torvalds 已提交
783
{
T
Takashi Iwai 已提交
784 785 786 787 788
	struct snd_pcm_str * pstr;
	struct snd_pcm_substream *substream;
	struct snd_pcm_runtime *runtime;
	struct snd_ctl_file *kctl;
	struct snd_card *card;
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796
	struct list_head *list;
	int prefer_subdevice = -1;
	size_t size;

	snd_assert(rsubstream != NULL, return -EINVAL);
	*rsubstream = NULL;
	snd_assert(pcm != NULL, return -ENXIO);
	pstr = &pcm->streams[stream];
797
	if (pstr->substream == NULL || pstr->substream_count == 0)
L
Linus Torvalds 已提交
798 799 800 801 802 803 804 805 806 807 808 809 810 811 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 837 838 839 840 841 842 843
		return -ENODEV;

	card = pcm->card;
	down_read(&card->controls_rwsem);
	list_for_each(list, &card->ctl_files) {
		kctl = snd_ctl_file(list);
		if (kctl->pid == current->pid) {
			prefer_subdevice = kctl->prefer_pcm_subdevice;
			break;
		}
	}
	up_read(&card->controls_rwsem);

	switch (stream) {
	case SNDRV_PCM_STREAM_PLAYBACK:
		if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
			for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next) {
				if (SUBSTREAM_BUSY(substream))
					return -EAGAIN;
			}
		}
		break;
	case SNDRV_PCM_STREAM_CAPTURE:
		if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
			for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) {
				if (SUBSTREAM_BUSY(substream))
					return -EAGAIN;
			}
		}
		break;
	default:
		return -EINVAL;
	}

	if (prefer_subdevice >= 0) {
		for (substream = pstr->substream; substream; substream = substream->next)
			if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice)
				goto __ok;
	}
	for (substream = pstr->substream; substream; substream = substream->next)
		if (!SUBSTREAM_BUSY(substream))
			break;
      __ok:
	if (substream == NULL)
		return -EAGAIN;

844
	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
L
Linus Torvalds 已提交
845 846 847
	if (runtime == NULL)
		return -ENOMEM;

T
Takashi Iwai 已提交
848
	size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
L
Linus Torvalds 已提交
849 850 851 852 853 854 855
	runtime->status = snd_malloc_pages(size, GFP_KERNEL);
	if (runtime->status == NULL) {
		kfree(runtime);
		return -ENOMEM;
	}
	memset((void*)runtime->status, 0, size);

T
Takashi Iwai 已提交
856
	size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
L
Linus Torvalds 已提交
857 858
	runtime->control = snd_malloc_pages(size, GFP_KERNEL);
	if (runtime->control == NULL) {
T
Takashi Iwai 已提交
859 860
		snd_free_pages((void*)runtime->status,
			       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
L
Linus Torvalds 已提交
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
		kfree(runtime);
		return -ENOMEM;
	}
	memset((void*)runtime->control, 0, size);

	init_waitqueue_head(&runtime->sleep);
	atomic_set(&runtime->mmap_count, 0);
	init_timer(&runtime->tick_timer);
	runtime->tick_timer.function = snd_pcm_tick_timer_func;
	runtime->tick_timer.data = (unsigned long) substream;

	runtime->status->state = SNDRV_PCM_STATE_OPEN;

	substream->runtime = runtime;
	substream->private_data = pcm->private_data;
876
	substream->ffile = file;
L
Linus Torvalds 已提交
877 878 879 880 881
	pstr->substream_opened++;
	*rsubstream = substream;
	return 0;
}

882
void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
L
Linus Torvalds 已提交
883
{
T
Takashi Iwai 已提交
884
	struct snd_pcm_runtime *runtime;
L
Linus Torvalds 已提交
885 886 887 888 889
	substream->file = NULL;
	runtime = substream->runtime;
	snd_assert(runtime != NULL, return);
	if (runtime->private_free != NULL)
		runtime->private_free(runtime);
T
Takashi Iwai 已提交
890 891 892 893
	snd_free_pages((void*)runtime->status,
		       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
	snd_free_pages((void*)runtime->control,
		       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
L
Linus Torvalds 已提交
894 895 896 897 898 899
	kfree(runtime->hw_constraints.rules);
	kfree(runtime);
	substream->runtime = NULL;
	substream->pstr->substream_opened--;
}

T
Takashi Iwai 已提交
900
static int snd_pcm_dev_register(struct snd_device *device)
L
Linus Torvalds 已提交
901
{
902
	int cidx, err;
T
Takashi Iwai 已提交
903
	struct snd_pcm_substream *substream;
L
Linus Torvalds 已提交
904 905
	struct list_head *list;
	char str[16];
T
Takashi Iwai 已提交
906
	struct snd_pcm *pcm = device->device_data;
L
Linus Torvalds 已提交
907 908

	snd_assert(pcm != NULL && device != NULL, return -ENXIO);
909
	mutex_lock(&register_mutex);
910
	if (snd_pcm_search(pcm->card, pcm->device)) {
911
		mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
912 913
		return -EBUSY;
	}
914
	list_add_tail(&pcm->list, &snd_pcm_devices);
L
Linus Torvalds 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928
	for (cidx = 0; cidx < 2; cidx++) {
		int devtype = -1;
		if (pcm->streams[cidx].substream == NULL)
			continue;
		switch (cidx) {
		case SNDRV_PCM_STREAM_PLAYBACK:
			sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
			devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
			break;
		case SNDRV_PCM_STREAM_CAPTURE:
			sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
			devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
			break;
		}
929 930
		if ((err = snd_register_device(devtype, pcm->card,
					       pcm->device,
931 932
					       &snd_pcm_f_ops[cidx],
					       pcm, str)) < 0)
933
		{
934
			list_del(&pcm->list);
935
			mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
936 937 938 939 940 941
			return err;
		}
		for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
			snd_pcm_timer_init(substream);
	}
	list_for_each(list, &snd_pcm_notify_list) {
T
Takashi Iwai 已提交
942 943
		struct snd_pcm_notify *notify;
		notify = list_entry(list, struct snd_pcm_notify, list);
L
Linus Torvalds 已提交
944 945
		notify->n_register(pcm);
	}
946
	mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
947 948 949
	return 0;
}

T
Takashi Iwai 已提交
950
static int snd_pcm_dev_disconnect(struct snd_device *device)
L
Linus Torvalds 已提交
951
{
T
Takashi Iwai 已提交
952
	struct snd_pcm *pcm = device->device_data;
L
Linus Torvalds 已提交
953
	struct list_head *list;
T
Takashi Iwai 已提交
954
	struct snd_pcm_substream *substream;
955
	int cidx;
L
Linus Torvalds 已提交
956

957
	mutex_lock(&register_mutex);
958
	list_del_init(&pcm->list);
L
Linus Torvalds 已提交
959 960 961 962 963
	for (cidx = 0; cidx < 2; cidx++)
		for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
			if (substream->runtime)
				substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
	list_for_each(list, &snd_pcm_notify_list) {
T
Takashi Iwai 已提交
964 965
		struct snd_pcm_notify *notify;
		notify = list_entry(list, struct snd_pcm_notify, list);
L
Linus Torvalds 已提交
966 967
		notify->n_disconnect(pcm);
	}
968
	mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
969 970 971
	return 0;
}

T
Takashi Iwai 已提交
972
static int snd_pcm_dev_unregister(struct snd_device *device)
L
Linus Torvalds 已提交
973
{
974
	int cidx, devtype;
T
Takashi Iwai 已提交
975
	struct snd_pcm_substream *substream;
L
Linus Torvalds 已提交
976
	struct list_head *list;
T
Takashi Iwai 已提交
977
	struct snd_pcm *pcm = device->device_data;
L
Linus Torvalds 已提交
978 979

	snd_assert(pcm != NULL, return -ENXIO);
980
	mutex_lock(&register_mutex);
981
	list_del(&pcm->list);
L
Linus Torvalds 已提交
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
	for (cidx = 0; cidx < 2; cidx++) {
		devtype = -1;
		switch (cidx) {
		case SNDRV_PCM_STREAM_PLAYBACK:
			devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
			break;
		case SNDRV_PCM_STREAM_CAPTURE:
			devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
			break;
		}
		snd_unregister_device(devtype, pcm->card, pcm->device);
		for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
			snd_pcm_timer_done(substream);
	}
	list_for_each(list, &snd_pcm_notify_list) {
T
Takashi Iwai 已提交
997 998
		struct snd_pcm_notify *notify;
		notify = list_entry(list, struct snd_pcm_notify, list);
L
Linus Torvalds 已提交
999 1000
		notify->n_unregister(pcm);
	}
1001
	mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
1002 1003 1004
	return snd_pcm_free(pcm);
}

T
Takashi Iwai 已提交
1005
int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
L
Linus Torvalds 已提交
1006
{
1007
	struct list_head *p;
L
Linus Torvalds 已提交
1008 1009

	snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL);
1010
	mutex_lock(&register_mutex);
L
Linus Torvalds 已提交
1011 1012
	if (nfree) {
		list_del(&notify->list);
1013 1014 1015
		list_for_each(p, &snd_pcm_devices)
			notify->n_unregister(list_entry(p,
							struct snd_pcm, list));
L
Linus Torvalds 已提交
1016 1017
	} else {
		list_add_tail(&notify->list, &snd_pcm_notify_list);
1018 1019
		list_for_each(p, &snd_pcm_devices)
			notify->n_register(list_entry(p, struct snd_pcm, list));
L
Linus Torvalds 已提交
1020
	}
1021
	mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
1022 1023 1024
	return 0;
}

1025
#ifdef CONFIG_PROC_FS
L
Linus Torvalds 已提交
1026 1027 1028 1029
/*
 *  Info interface
 */

T
Takashi Iwai 已提交
1030 1031
static void snd_pcm_proc_read(struct snd_info_entry *entry,
			      struct snd_info_buffer *buffer)
L
Linus Torvalds 已提交
1032
{
1033
	struct list_head *p;
T
Takashi Iwai 已提交
1034
	struct snd_pcm *pcm;
L
Linus Torvalds 已提交
1035

1036
	mutex_lock(&register_mutex);
1037 1038 1039 1040
	list_for_each(p, &snd_pcm_devices) {
		pcm = list_entry(p, struct snd_pcm, list);
		snd_iprintf(buffer, "%02i-%02i: %s : %s",
			    pcm->card->number, pcm->device, pcm->id, pcm->name);
L
Linus Torvalds 已提交
1041
		if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
T
Takashi Iwai 已提交
1042 1043
			snd_iprintf(buffer, " : playback %i",
				    pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
L
Linus Torvalds 已提交
1044
		if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
T
Takashi Iwai 已提交
1045 1046
			snd_iprintf(buffer, " : capture %i",
				    pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
L
Linus Torvalds 已提交
1047 1048
		snd_iprintf(buffer, "\n");
	}
1049
	mutex_unlock(&register_mutex);
L
Linus Torvalds 已提交
1050 1051
}

T
Takashi Iwai 已提交
1052
static struct snd_info_entry *snd_pcm_proc_entry = NULL;
L
Linus Torvalds 已提交
1053

1054
static void snd_pcm_proc_init(void)
L
Linus Torvalds 已提交
1055
{
T
Takashi Iwai 已提交
1056
	struct snd_info_entry *entry;
L
Linus Torvalds 已提交
1057 1058

	if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
T
Takashi Iwai 已提交
1059 1060
		snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128,
				      snd_pcm_proc_read);
L
Linus Torvalds 已提交
1061 1062 1063 1064 1065 1066
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	snd_pcm_proc_entry = entry;
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
}

static void snd_pcm_proc_done(void)
{
	if (snd_pcm_proc_entry)
		snd_info_unregister(snd_pcm_proc_entry);
}

#else /* !CONFIG_PROC_FS */
#define snd_pcm_proc_init()
#define snd_pcm_proc_done()
#endif /* CONFIG_PROC_FS */


/*
 *  ENTRY functions
 */

static int __init alsa_pcm_init(void)
{
	snd_ctl_register_ioctl(snd_pcm_control_ioctl);
	snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
	snd_pcm_proc_init();
L
Linus Torvalds 已提交
1090 1091 1092 1093 1094 1095 1096
	return 0;
}

static void __exit alsa_pcm_exit(void)
{
	snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
	snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
1097
	snd_pcm_proc_done();
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
}

module_init(alsa_pcm_init)
module_exit(alsa_pcm_exit)

EXPORT_SYMBOL(snd_pcm_new);
EXPORT_SYMBOL(snd_pcm_new_stream);
EXPORT_SYMBOL(snd_pcm_notify);
EXPORT_SYMBOL(snd_pcm_open_substream);
EXPORT_SYMBOL(snd_pcm_release_substream);
  /* pcm_native.c */
EXPORT_SYMBOL(snd_pcm_link_rwlock);
#ifdef CONFIG_PM
EXPORT_SYMBOL(snd_pcm_suspend);
EXPORT_SYMBOL(snd_pcm_suspend_all);
#endif
EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
EXPORT_SYMBOL(snd_pcm_mmap_data);
#if SNDRV_PCM_INFO_MMAP_IOMEM
EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
#endif
 /* pcm_misc.c */
EXPORT_SYMBOL(snd_pcm_format_signed);
EXPORT_SYMBOL(snd_pcm_format_unsigned);
EXPORT_SYMBOL(snd_pcm_format_linear);
EXPORT_SYMBOL(snd_pcm_format_little_endian);
EXPORT_SYMBOL(snd_pcm_format_big_endian);
EXPORT_SYMBOL(snd_pcm_format_width);
EXPORT_SYMBOL(snd_pcm_format_physical_width);
1127
EXPORT_SYMBOL(snd_pcm_format_size);
L
Linus Torvalds 已提交
1128 1129 1130 1131
EXPORT_SYMBOL(snd_pcm_format_silence_64);
EXPORT_SYMBOL(snd_pcm_format_set_silence);
EXPORT_SYMBOL(snd_pcm_build_linear_format);
EXPORT_SYMBOL(snd_pcm_limit_hw_rates);