xref: /openbmc/linux/sound/core/pcm.c (revision b04b4f78)
1 /*
2  *  Digital Audio (PCM) abstract layer
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/mutex.h>
26 #include <sound/core.h>
27 #include <sound/minors.h>
28 #include <sound/pcm.h>
29 #include <sound/control.h>
30 #include <sound/info.h>
31 
32 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
33 MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
34 MODULE_LICENSE("GPL");
35 
36 static LIST_HEAD(snd_pcm_devices);
37 static LIST_HEAD(snd_pcm_notify_list);
38 static DEFINE_MUTEX(register_mutex);
39 
40 static int snd_pcm_free(struct snd_pcm *pcm);
41 static int snd_pcm_dev_free(struct snd_device *device);
42 static int snd_pcm_dev_register(struct snd_device *device);
43 static int snd_pcm_dev_disconnect(struct snd_device *device);
44 
45 static struct snd_pcm *snd_pcm_get(struct snd_card *card, int device)
46 {
47 	struct snd_pcm *pcm;
48 
49 	list_for_each_entry(pcm, &snd_pcm_devices, list) {
50 		if (pcm->card == card && pcm->device == device)
51 			return pcm;
52 	}
53 	return NULL;
54 }
55 
56 static int snd_pcm_next(struct snd_card *card, int device)
57 {
58 	struct snd_pcm *pcm;
59 
60 	list_for_each_entry(pcm, &snd_pcm_devices, list) {
61 		if (pcm->card == card && pcm->device > device)
62 			return pcm->device;
63 		else if (pcm->card->number > card->number)
64 			return -1;
65 	}
66 	return -1;
67 }
68 
69 static int snd_pcm_add(struct snd_pcm *newpcm)
70 {
71 	struct snd_pcm *pcm;
72 
73 	list_for_each_entry(pcm, &snd_pcm_devices, list) {
74 		if (pcm->card == newpcm->card && pcm->device == newpcm->device)
75 			return -EBUSY;
76 		if (pcm->card->number > newpcm->card->number ||
77 				(pcm->card == newpcm->card &&
78 				pcm->device > newpcm->device)) {
79 			list_add(&newpcm->list, pcm->list.prev);
80 			return 0;
81 		}
82 	}
83 	list_add_tail(&newpcm->list, &snd_pcm_devices);
84 	return 0;
85 }
86 
87 static int snd_pcm_control_ioctl(struct snd_card *card,
88 				 struct snd_ctl_file *control,
89 				 unsigned int cmd, unsigned long arg)
90 {
91 	switch (cmd) {
92 	case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
93 		{
94 			int device;
95 
96 			if (get_user(device, (int __user *)arg))
97 				return -EFAULT;
98 			mutex_lock(&register_mutex);
99 			device = snd_pcm_next(card, device);
100 			mutex_unlock(&register_mutex);
101 			if (put_user(device, (int __user *)arg))
102 				return -EFAULT;
103 			return 0;
104 		}
105 	case SNDRV_CTL_IOCTL_PCM_INFO:
106 		{
107 			struct snd_pcm_info __user *info;
108 			unsigned int device, subdevice;
109 			int stream;
110 			struct snd_pcm *pcm;
111 			struct snd_pcm_str *pstr;
112 			struct snd_pcm_substream *substream;
113 			int err;
114 
115 			info = (struct snd_pcm_info __user *)arg;
116 			if (get_user(device, &info->device))
117 				return -EFAULT;
118 			if (get_user(stream, &info->stream))
119 				return -EFAULT;
120 			if (stream < 0 || stream > 1)
121 				return -EINVAL;
122 			if (get_user(subdevice, &info->subdevice))
123 				return -EFAULT;
124 			mutex_lock(&register_mutex);
125 			pcm = snd_pcm_get(card, device);
126 			if (pcm == NULL) {
127 				err = -ENXIO;
128 				goto _error;
129 			}
130 			pstr = &pcm->streams[stream];
131 			if (pstr->substream_count == 0) {
132 				err = -ENOENT;
133 				goto _error;
134 			}
135 			if (subdevice >= pstr->substream_count) {
136 				err = -ENXIO;
137 				goto _error;
138 			}
139 			for (substream = pstr->substream; substream;
140 			     substream = substream->next)
141 				if (substream->number == (int)subdevice)
142 					break;
143 			if (substream == NULL) {
144 				err = -ENXIO;
145 				goto _error;
146 			}
147 			err = snd_pcm_info_user(substream, info);
148 		_error:
149 			mutex_unlock(&register_mutex);
150 			return err;
151 		}
152 	case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
153 		{
154 			int val;
155 
156 			if (get_user(val, (int __user *)arg))
157 				return -EFAULT;
158 			control->prefer_pcm_subdevice = val;
159 			return 0;
160 		}
161 	}
162 	return -ENOIOCTLCMD;
163 }
164 
165 #ifdef CONFIG_SND_VERBOSE_PROCFS
166 
167 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
168 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
169 #define READY(v) [SNDRV_PCM_READY_##v] = #v
170 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
171 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
172 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
173 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
174 #define START(v) [SNDRV_PCM_START_##v] = #v
175 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
176 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
177 
178 static char *snd_pcm_format_names[] = {
179 	FORMAT(S8),
180 	FORMAT(U8),
181 	FORMAT(S16_LE),
182 	FORMAT(S16_BE),
183 	FORMAT(U16_LE),
184 	FORMAT(U16_BE),
185 	FORMAT(S24_LE),
186 	FORMAT(S24_BE),
187 	FORMAT(U24_LE),
188 	FORMAT(U24_BE),
189 	FORMAT(S32_LE),
190 	FORMAT(S32_BE),
191 	FORMAT(U32_LE),
192 	FORMAT(U32_BE),
193 	FORMAT(FLOAT_LE),
194 	FORMAT(FLOAT_BE),
195 	FORMAT(FLOAT64_LE),
196 	FORMAT(FLOAT64_BE),
197 	FORMAT(IEC958_SUBFRAME_LE),
198 	FORMAT(IEC958_SUBFRAME_BE),
199 	FORMAT(MU_LAW),
200 	FORMAT(A_LAW),
201 	FORMAT(IMA_ADPCM),
202 	FORMAT(MPEG),
203 	FORMAT(GSM),
204 	FORMAT(SPECIAL),
205 	FORMAT(S24_3LE),
206 	FORMAT(S24_3BE),
207 	FORMAT(U24_3LE),
208 	FORMAT(U24_3BE),
209 	FORMAT(S20_3LE),
210 	FORMAT(S20_3BE),
211 	FORMAT(U20_3LE),
212 	FORMAT(U20_3BE),
213 	FORMAT(S18_3LE),
214 	FORMAT(S18_3BE),
215 	FORMAT(U18_3LE),
216 	FORMAT(U18_3BE),
217 };
218 
219 static const char *snd_pcm_format_name(snd_pcm_format_t format)
220 {
221 	return snd_pcm_format_names[format];
222 }
223 
224 static char *snd_pcm_stream_names[] = {
225 	STREAM(PLAYBACK),
226 	STREAM(CAPTURE),
227 };
228 
229 static char *snd_pcm_state_names[] = {
230 	STATE(OPEN),
231 	STATE(SETUP),
232 	STATE(PREPARED),
233 	STATE(RUNNING),
234 	STATE(XRUN),
235 	STATE(DRAINING),
236 	STATE(PAUSED),
237 	STATE(SUSPENDED),
238 };
239 
240 static char *snd_pcm_access_names[] = {
241 	ACCESS(MMAP_INTERLEAVED),
242 	ACCESS(MMAP_NONINTERLEAVED),
243 	ACCESS(MMAP_COMPLEX),
244 	ACCESS(RW_INTERLEAVED),
245 	ACCESS(RW_NONINTERLEAVED),
246 };
247 
248 static char *snd_pcm_subformat_names[] = {
249 	SUBFORMAT(STD),
250 };
251 
252 static char *snd_pcm_tstamp_mode_names[] = {
253 	TSTAMP(NONE),
254 	TSTAMP(ENABLE),
255 };
256 
257 static const char *snd_pcm_stream_name(int stream)
258 {
259 	return snd_pcm_stream_names[stream];
260 }
261 
262 static const char *snd_pcm_access_name(snd_pcm_access_t access)
263 {
264 	return snd_pcm_access_names[access];
265 }
266 
267 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
268 {
269 	return snd_pcm_subformat_names[subformat];
270 }
271 
272 static const char *snd_pcm_tstamp_mode_name(int mode)
273 {
274 	return snd_pcm_tstamp_mode_names[mode];
275 }
276 
277 static const char *snd_pcm_state_name(snd_pcm_state_t state)
278 {
279 	return snd_pcm_state_names[state];
280 }
281 
282 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
283 #include <linux/soundcard.h>
284 
285 static const char *snd_pcm_oss_format_name(int format)
286 {
287 	switch (format) {
288 	case AFMT_MU_LAW:
289 		return "MU_LAW";
290 	case AFMT_A_LAW:
291 		return "A_LAW";
292 	case AFMT_IMA_ADPCM:
293 		return "IMA_ADPCM";
294 	case AFMT_U8:
295 		return "U8";
296 	case AFMT_S16_LE:
297 		return "S16_LE";
298 	case AFMT_S16_BE:
299 		return "S16_BE";
300 	case AFMT_S8:
301 		return "S8";
302 	case AFMT_U16_LE:
303 		return "U16_LE";
304 	case AFMT_U16_BE:
305 		return "U16_BE";
306 	case AFMT_MPEG:
307 		return "MPEG";
308 	default:
309 		return "unknown";
310 	}
311 }
312 #endif
313 
314 static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
315 				   struct snd_info_buffer *buffer)
316 {
317 	struct snd_pcm_info *info;
318 	int err;
319 
320 	if (! substream)
321 		return;
322 
323 	info = kmalloc(sizeof(*info), GFP_KERNEL);
324 	if (! info) {
325 		printk(KERN_DEBUG "snd_pcm_proc_info_read: cannot malloc\n");
326 		return;
327 	}
328 
329 	err = snd_pcm_info(substream, info);
330 	if (err < 0) {
331 		snd_iprintf(buffer, "error %d\n", err);
332 		kfree(info);
333 		return;
334 	}
335 	snd_iprintf(buffer, "card: %d\n", info->card);
336 	snd_iprintf(buffer, "device: %d\n", info->device);
337 	snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
338 	snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
339 	snd_iprintf(buffer, "id: %s\n", info->id);
340 	snd_iprintf(buffer, "name: %s\n", info->name);
341 	snd_iprintf(buffer, "subname: %s\n", info->subname);
342 	snd_iprintf(buffer, "class: %d\n", info->dev_class);
343 	snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
344 	snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
345 	snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
346 	kfree(info);
347 }
348 
349 static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
350 					  struct snd_info_buffer *buffer)
351 {
352 	snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
353 			       buffer);
354 }
355 
356 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
357 					     struct snd_info_buffer *buffer)
358 {
359 	snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
360 			       buffer);
361 }
362 
363 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
364 						  struct snd_info_buffer *buffer)
365 {
366 	struct snd_pcm_substream *substream = entry->private_data;
367 	struct snd_pcm_runtime *runtime = substream->runtime;
368 	if (!runtime) {
369 		snd_iprintf(buffer, "closed\n");
370 		return;
371 	}
372 	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
373 		snd_iprintf(buffer, "no setup\n");
374 		return;
375 	}
376 	snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
377 	snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
378 	snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
379 	snd_iprintf(buffer, "channels: %u\n", runtime->channels);
380 	snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den);
381 	snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);
382 	snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);
383 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
384 	if (substream->oss.oss) {
385 		snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
386 		snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);
387 		snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate);
388 		snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes);
389 		snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods);
390 		snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
391 	}
392 #endif
393 }
394 
395 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
396 						  struct snd_info_buffer *buffer)
397 {
398 	struct snd_pcm_substream *substream = entry->private_data;
399 	struct snd_pcm_runtime *runtime = substream->runtime;
400 	if (!runtime) {
401 		snd_iprintf(buffer, "closed\n");
402 		return;
403 	}
404 	if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
405 		snd_iprintf(buffer, "no setup\n");
406 		return;
407 	}
408 	snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
409 	snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
410 	snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
411 	snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
412 	snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
413 	snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
414 	snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
415 	snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
416 }
417 
418 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
419 					       struct snd_info_buffer *buffer)
420 {
421 	struct snd_pcm_substream *substream = entry->private_data;
422 	struct snd_pcm_runtime *runtime = substream->runtime;
423 	struct snd_pcm_status status;
424 	int err;
425 	if (!runtime) {
426 		snd_iprintf(buffer, "closed\n");
427 		return;
428 	}
429 	memset(&status, 0, sizeof(status));
430 	err = snd_pcm_status(substream, &status);
431 	if (err < 0) {
432 		snd_iprintf(buffer, "error %d\n", err);
433 		return;
434 	}
435 	snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
436 	snd_iprintf(buffer, "trigger_time: %ld.%09ld\n",
437 		status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec);
438 	snd_iprintf(buffer, "tstamp      : %ld.%09ld\n",
439 		status.tstamp.tv_sec, status.tstamp.tv_nsec);
440 	snd_iprintf(buffer, "delay       : %ld\n", status.delay);
441 	snd_iprintf(buffer, "avail       : %ld\n", status.avail);
442 	snd_iprintf(buffer, "avail_max   : %ld\n", status.avail_max);
443 	snd_iprintf(buffer, "-----\n");
444 	snd_iprintf(buffer, "hw_ptr      : %ld\n", runtime->status->hw_ptr);
445 	snd_iprintf(buffer, "appl_ptr    : %ld\n", runtime->control->appl_ptr);
446 }
447 
448 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
449 static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
450 				    struct snd_info_buffer *buffer)
451 {
452 	struct snd_pcm_str *pstr = entry->private_data;
453 	snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
454 }
455 
456 static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
457 				     struct snd_info_buffer *buffer)
458 {
459 	struct snd_pcm_str *pstr = entry->private_data;
460 	char line[64];
461 	if (!snd_info_get_line(buffer, line, sizeof(line)))
462 		pstr->xrun_debug = simple_strtoul(line, NULL, 10);
463 }
464 #endif
465 
466 static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
467 {
468 	struct snd_pcm *pcm = pstr->pcm;
469 	struct snd_info_entry *entry;
470 	char name[16];
471 
472 	sprintf(name, "pcm%i%c", pcm->device,
473 		pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
474 	if ((entry = snd_info_create_card_entry(pcm->card, name, pcm->card->proc_root)) == NULL)
475 		return -ENOMEM;
476 	entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
477 	if (snd_info_register(entry) < 0) {
478 		snd_info_free_entry(entry);
479 		return -ENOMEM;
480 	}
481 	pstr->proc_root = entry;
482 
483 	if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
484 		snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
485 		if (snd_info_register(entry) < 0) {
486 			snd_info_free_entry(entry);
487 			entry = NULL;
488 		}
489 	}
490 	pstr->proc_info_entry = entry;
491 
492 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
493 	if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
494 						pstr->proc_root)) != NULL) {
495 		entry->c.text.read = snd_pcm_xrun_debug_read;
496 		entry->c.text.write = snd_pcm_xrun_debug_write;
497 		entry->mode |= S_IWUSR;
498 		entry->private_data = pstr;
499 		if (snd_info_register(entry) < 0) {
500 			snd_info_free_entry(entry);
501 			entry = NULL;
502 		}
503 	}
504 	pstr->proc_xrun_debug_entry = entry;
505 #endif
506 	return 0;
507 }
508 
509 static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
510 {
511 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
512 	snd_info_free_entry(pstr->proc_xrun_debug_entry);
513 	pstr->proc_xrun_debug_entry = NULL;
514 #endif
515 	snd_info_free_entry(pstr->proc_info_entry);
516 	pstr->proc_info_entry = NULL;
517 	snd_info_free_entry(pstr->proc_root);
518 	pstr->proc_root = NULL;
519 	return 0;
520 }
521 
522 static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
523 {
524 	struct snd_info_entry *entry;
525 	struct snd_card *card;
526 	char name[16];
527 
528 	card = substream->pcm->card;
529 
530 	sprintf(name, "sub%i", substream->number);
531 	if ((entry = snd_info_create_card_entry(card, name, substream->pstr->proc_root)) == NULL)
532 		return -ENOMEM;
533 	entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
534 	if (snd_info_register(entry) < 0) {
535 		snd_info_free_entry(entry);
536 		return -ENOMEM;
537 	}
538 	substream->proc_root = entry;
539 
540 	if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
541 		snd_info_set_text_ops(entry, substream,
542 				      snd_pcm_substream_proc_info_read);
543 		if (snd_info_register(entry) < 0) {
544 			snd_info_free_entry(entry);
545 			entry = NULL;
546 		}
547 	}
548 	substream->proc_info_entry = entry;
549 
550 	if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
551 		snd_info_set_text_ops(entry, substream,
552 				      snd_pcm_substream_proc_hw_params_read);
553 		if (snd_info_register(entry) < 0) {
554 			snd_info_free_entry(entry);
555 			entry = NULL;
556 		}
557 	}
558 	substream->proc_hw_params_entry = entry;
559 
560 	if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
561 		snd_info_set_text_ops(entry, substream,
562 				      snd_pcm_substream_proc_sw_params_read);
563 		if (snd_info_register(entry) < 0) {
564 			snd_info_free_entry(entry);
565 			entry = NULL;
566 		}
567 	}
568 	substream->proc_sw_params_entry = entry;
569 
570 	if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
571 		snd_info_set_text_ops(entry, substream,
572 				      snd_pcm_substream_proc_status_read);
573 		if (snd_info_register(entry) < 0) {
574 			snd_info_free_entry(entry);
575 			entry = NULL;
576 		}
577 	}
578 	substream->proc_status_entry = entry;
579 
580 	return 0;
581 }
582 
583 static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream)
584 {
585 	snd_info_free_entry(substream->proc_info_entry);
586 	substream->proc_info_entry = NULL;
587 	snd_info_free_entry(substream->proc_hw_params_entry);
588 	substream->proc_hw_params_entry = NULL;
589 	snd_info_free_entry(substream->proc_sw_params_entry);
590 	substream->proc_sw_params_entry = NULL;
591 	snd_info_free_entry(substream->proc_status_entry);
592 	substream->proc_status_entry = NULL;
593 	snd_info_free_entry(substream->proc_root);
594 	substream->proc_root = NULL;
595 	return 0;
596 }
597 #else /* !CONFIG_SND_VERBOSE_PROCFS */
598 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
599 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
600 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
601 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; }
602 #endif /* CONFIG_SND_VERBOSE_PROCFS */
603 
604 /**
605  * snd_pcm_new_stream - create a new PCM stream
606  * @pcm: the pcm instance
607  * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
608  * @substream_count: the number of substreams
609  *
610  * Creates a new stream for the pcm.
611  * The corresponding stream on the pcm must have been empty before
612  * calling this, i.e. zero must be given to the argument of
613  * snd_pcm_new().
614  *
615  * Returns zero if successful, or a negative error code on failure.
616  */
617 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
618 {
619 	int idx, err;
620 	struct snd_pcm_str *pstr = &pcm->streams[stream];
621 	struct snd_pcm_substream *substream, *prev;
622 
623 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
624 	mutex_init(&pstr->oss.setup_mutex);
625 #endif
626 	pstr->stream = stream;
627 	pstr->pcm = pcm;
628 	pstr->substream_count = substream_count;
629 	if (substream_count > 0) {
630 		err = snd_pcm_stream_proc_init(pstr);
631 		if (err < 0) {
632 			snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
633 			return err;
634 		}
635 	}
636 	prev = NULL;
637 	for (idx = 0, prev = NULL; idx < substream_count; idx++) {
638 		substream = kzalloc(sizeof(*substream), GFP_KERNEL);
639 		if (substream == NULL) {
640 			snd_printk(KERN_ERR "Cannot allocate PCM substream\n");
641 			return -ENOMEM;
642 		}
643 		substream->pcm = pcm;
644 		substream->pstr = pstr;
645 		substream->number = idx;
646 		substream->stream = stream;
647 		sprintf(substream->name, "subdevice #%i", idx);
648 		snprintf(substream->latency_id, sizeof(substream->latency_id),
649 			 "ALSA-PCM%d-%d%c%d", pcm->card->number, pcm->device,
650 			 (stream ? 'c' : 'p'), idx);
651 		substream->buffer_bytes_max = UINT_MAX;
652 		if (prev == NULL)
653 			pstr->substream = substream;
654 		else
655 			prev->next = substream;
656 		err = snd_pcm_substream_proc_init(substream);
657 		if (err < 0) {
658 			snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
659 			if (prev == NULL)
660 				pstr->substream = NULL;
661 			else
662 				prev->next = NULL;
663 			kfree(substream);
664 			return err;
665 		}
666 		substream->group = &substream->self_group;
667 		spin_lock_init(&substream->self_group.lock);
668 		INIT_LIST_HEAD(&substream->self_group.substreams);
669 		list_add_tail(&substream->link_list, &substream->self_group.substreams);
670 		atomic_set(&substream->mmap_count, 0);
671 		prev = substream;
672 	}
673 	return 0;
674 }
675 
676 EXPORT_SYMBOL(snd_pcm_new_stream);
677 
678 /**
679  * snd_pcm_new - create a new PCM instance
680  * @card: the card instance
681  * @id: the id string
682  * @device: the device index (zero based)
683  * @playback_count: the number of substreams for playback
684  * @capture_count: the number of substreams for capture
685  * @rpcm: the pointer to store the new pcm instance
686  *
687  * Creates a new PCM instance.
688  *
689  * The pcm operators have to be set afterwards to the new instance
690  * via snd_pcm_set_ops().
691  *
692  * Returns zero if successful, or a negative error code on failure.
693  */
694 int snd_pcm_new(struct snd_card *card, const char *id, int device,
695 		int playback_count, int capture_count,
696 	        struct snd_pcm ** rpcm)
697 {
698 	struct snd_pcm *pcm;
699 	int err;
700 	static struct snd_device_ops ops = {
701 		.dev_free = snd_pcm_dev_free,
702 		.dev_register =	snd_pcm_dev_register,
703 		.dev_disconnect = snd_pcm_dev_disconnect,
704 	};
705 
706 	if (snd_BUG_ON(!card))
707 		return -ENXIO;
708 	if (rpcm)
709 		*rpcm = NULL;
710 	pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
711 	if (pcm == NULL) {
712 		snd_printk(KERN_ERR "Cannot allocate PCM\n");
713 		return -ENOMEM;
714 	}
715 	pcm->card = card;
716 	pcm->device = device;
717 	if (id)
718 		strlcpy(pcm->id, id, sizeof(pcm->id));
719 	if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {
720 		snd_pcm_free(pcm);
721 		return err;
722 	}
723 	if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) {
724 		snd_pcm_free(pcm);
725 		return err;
726 	}
727 	mutex_init(&pcm->open_mutex);
728 	init_waitqueue_head(&pcm->open_wait);
729 	if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {
730 		snd_pcm_free(pcm);
731 		return err;
732 	}
733 	if (rpcm)
734 		*rpcm = pcm;
735 	return 0;
736 }
737 
738 EXPORT_SYMBOL(snd_pcm_new);
739 
740 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
741 {
742 	struct snd_pcm_substream *substream, *substream_next;
743 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
744 	struct snd_pcm_oss_setup *setup, *setupn;
745 #endif
746 	substream = pstr->substream;
747 	while (substream) {
748 		substream_next = substream->next;
749 		snd_pcm_timer_done(substream);
750 		snd_pcm_substream_proc_done(substream);
751 		kfree(substream);
752 		substream = substream_next;
753 	}
754 	snd_pcm_stream_proc_done(pstr);
755 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
756 	for (setup = pstr->oss.setup_list; setup; setup = setupn) {
757 		setupn = setup->next;
758 		kfree(setup->task_name);
759 		kfree(setup);
760 	}
761 #endif
762 }
763 
764 static int snd_pcm_free(struct snd_pcm *pcm)
765 {
766 	struct snd_pcm_notify *notify;
767 
768 	if (!pcm)
769 		return 0;
770 	list_for_each_entry(notify, &snd_pcm_notify_list, list) {
771 		notify->n_unregister(pcm);
772 	}
773 	if (pcm->private_free)
774 		pcm->private_free(pcm);
775 	snd_pcm_lib_preallocate_free_for_all(pcm);
776 	snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
777 	snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
778 	kfree(pcm);
779 	return 0;
780 }
781 
782 static int snd_pcm_dev_free(struct snd_device *device)
783 {
784 	struct snd_pcm *pcm = device->device_data;
785 	return snd_pcm_free(pcm);
786 }
787 
788 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
789 			     struct file *file,
790 			     struct snd_pcm_substream **rsubstream)
791 {
792 	struct snd_pcm_str * pstr;
793 	struct snd_pcm_substream *substream;
794 	struct snd_pcm_runtime *runtime;
795 	struct snd_ctl_file *kctl;
796 	struct snd_card *card;
797 	int prefer_subdevice = -1;
798 	size_t size;
799 
800 	if (snd_BUG_ON(!pcm || !rsubstream))
801 		return -ENXIO;
802 	*rsubstream = NULL;
803 	pstr = &pcm->streams[stream];
804 	if (pstr->substream == NULL || pstr->substream_count == 0)
805 		return -ENODEV;
806 
807 	card = pcm->card;
808 	read_lock(&card->ctl_files_rwlock);
809 	list_for_each_entry(kctl, &card->ctl_files, list) {
810 		if (kctl->pid == current->pid) {
811 			prefer_subdevice = kctl->prefer_pcm_subdevice;
812 			if (prefer_subdevice != -1)
813 				break;
814 		}
815 	}
816 	read_unlock(&card->ctl_files_rwlock);
817 
818 	switch (stream) {
819 	case SNDRV_PCM_STREAM_PLAYBACK:
820 		if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
821 			for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next) {
822 				if (SUBSTREAM_BUSY(substream))
823 					return -EAGAIN;
824 			}
825 		}
826 		break;
827 	case SNDRV_PCM_STREAM_CAPTURE:
828 		if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
829 			for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) {
830 				if (SUBSTREAM_BUSY(substream))
831 					return -EAGAIN;
832 			}
833 		}
834 		break;
835 	default:
836 		return -EINVAL;
837 	}
838 
839 	if (file->f_flags & O_APPEND) {
840 		if (prefer_subdevice < 0) {
841 			if (pstr->substream_count > 1)
842 				return -EINVAL; /* must be unique */
843 			substream = pstr->substream;
844 		} else {
845 			for (substream = pstr->substream; substream;
846 			     substream = substream->next)
847 				if (substream->number == prefer_subdevice)
848 					break;
849 		}
850 		if (! substream)
851 			return -ENODEV;
852 		if (! SUBSTREAM_BUSY(substream))
853 			return -EBADFD;
854 		substream->ref_count++;
855 		*rsubstream = substream;
856 		return 0;
857 	}
858 
859 	if (prefer_subdevice >= 0) {
860 		for (substream = pstr->substream; substream; substream = substream->next)
861 			if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice)
862 				goto __ok;
863 	}
864 	for (substream = pstr->substream; substream; substream = substream->next)
865 		if (!SUBSTREAM_BUSY(substream))
866 			break;
867       __ok:
868 	if (substream == NULL)
869 		return -EAGAIN;
870 
871 	runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
872 	if (runtime == NULL)
873 		return -ENOMEM;
874 
875 	size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
876 	runtime->status = snd_malloc_pages(size, GFP_KERNEL);
877 	if (runtime->status == NULL) {
878 		kfree(runtime);
879 		return -ENOMEM;
880 	}
881 	memset((void*)runtime->status, 0, size);
882 
883 	size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
884 	runtime->control = snd_malloc_pages(size, GFP_KERNEL);
885 	if (runtime->control == NULL) {
886 		snd_free_pages((void*)runtime->status,
887 			       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
888 		kfree(runtime);
889 		return -ENOMEM;
890 	}
891 	memset((void*)runtime->control, 0, size);
892 
893 	init_waitqueue_head(&runtime->sleep);
894 
895 	runtime->status->state = SNDRV_PCM_STATE_OPEN;
896 
897 	substream->runtime = runtime;
898 	substream->private_data = pcm->private_data;
899 	substream->ref_count = 1;
900 	substream->f_flags = file->f_flags;
901 	pstr->substream_opened++;
902 	*rsubstream = substream;
903 	return 0;
904 }
905 
906 void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
907 {
908 	struct snd_pcm_runtime *runtime;
909 
910 	if (PCM_RUNTIME_CHECK(substream))
911 		return;
912 	runtime = substream->runtime;
913 	if (runtime->private_free != NULL)
914 		runtime->private_free(runtime);
915 	snd_free_pages((void*)runtime->status,
916 		       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
917 	snd_free_pages((void*)runtime->control,
918 		       PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
919 	kfree(runtime->hw_constraints.rules);
920 	kfree(runtime);
921 	substream->runtime = NULL;
922 	substream->pstr->substream_opened--;
923 }
924 
925 static ssize_t show_pcm_class(struct device *dev,
926 			      struct device_attribute *attr, char *buf)
927 {
928 	struct snd_pcm *pcm;
929 	const char *str;
930 	static const char *strs[SNDRV_PCM_CLASS_LAST + 1] = {
931 		[SNDRV_PCM_CLASS_GENERIC] = "generic",
932 		[SNDRV_PCM_CLASS_MULTI] = "multi",
933 		[SNDRV_PCM_CLASS_MODEM] = "modem",
934 		[SNDRV_PCM_CLASS_DIGITIZER] = "digitizer",
935 	};
936 
937 	if (! (pcm = dev_get_drvdata(dev)) ||
938 	    pcm->dev_class > SNDRV_PCM_CLASS_LAST)
939 		str = "none";
940 	else
941 		str = strs[pcm->dev_class];
942         return snprintf(buf, PAGE_SIZE, "%s\n", str);
943 }
944 
945 static struct device_attribute pcm_attrs =
946 	__ATTR(pcm_class, S_IRUGO, show_pcm_class, NULL);
947 
948 static int snd_pcm_dev_register(struct snd_device *device)
949 {
950 	int cidx, err;
951 	struct snd_pcm_substream *substream;
952 	struct snd_pcm_notify *notify;
953 	char str[16];
954 	struct snd_pcm *pcm = device->device_data;
955 	struct device *dev;
956 
957 	if (snd_BUG_ON(!pcm || !device))
958 		return -ENXIO;
959 	mutex_lock(&register_mutex);
960 	err = snd_pcm_add(pcm);
961 	if (err) {
962 		mutex_unlock(&register_mutex);
963 		return err;
964 	}
965 	for (cidx = 0; cidx < 2; cidx++) {
966 		int devtype = -1;
967 		if (pcm->streams[cidx].substream == NULL)
968 			continue;
969 		switch (cidx) {
970 		case SNDRV_PCM_STREAM_PLAYBACK:
971 			sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
972 			devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
973 			break;
974 		case SNDRV_PCM_STREAM_CAPTURE:
975 			sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
976 			devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
977 			break;
978 		}
979 		/* device pointer to use, pcm->dev takes precedence if
980 		 * it is assigned, otherwise fall back to card's device
981 		 * if possible */
982 		dev = pcm->dev;
983 		if (!dev)
984 			dev = snd_card_get_device_link(pcm->card);
985 		/* register pcm */
986 		err = snd_register_device_for_dev(devtype, pcm->card,
987 						  pcm->device,
988 						  &snd_pcm_f_ops[cidx],
989 						  pcm, str, dev);
990 		if (err < 0) {
991 			list_del(&pcm->list);
992 			mutex_unlock(&register_mutex);
993 			return err;
994 		}
995 		snd_add_device_sysfs_file(devtype, pcm->card, pcm->device,
996 					  &pcm_attrs);
997 		for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
998 			snd_pcm_timer_init(substream);
999 	}
1000 
1001 	list_for_each_entry(notify, &snd_pcm_notify_list, list)
1002 		notify->n_register(pcm);
1003 
1004 	mutex_unlock(&register_mutex);
1005 	return 0;
1006 }
1007 
1008 static int snd_pcm_dev_disconnect(struct snd_device *device)
1009 {
1010 	struct snd_pcm *pcm = device->device_data;
1011 	struct snd_pcm_notify *notify;
1012 	struct snd_pcm_substream *substream;
1013 	int cidx, devtype;
1014 
1015 	mutex_lock(&register_mutex);
1016 	if (list_empty(&pcm->list))
1017 		goto unlock;
1018 
1019 	list_del_init(&pcm->list);
1020 	for (cidx = 0; cidx < 2; cidx++)
1021 		for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
1022 			if (substream->runtime)
1023 				substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
1024 	list_for_each_entry(notify, &snd_pcm_notify_list, list) {
1025 		notify->n_disconnect(pcm);
1026 	}
1027 	for (cidx = 0; cidx < 2; cidx++) {
1028 		devtype = -1;
1029 		switch (cidx) {
1030 		case SNDRV_PCM_STREAM_PLAYBACK:
1031 			devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
1032 			break;
1033 		case SNDRV_PCM_STREAM_CAPTURE:
1034 			devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
1035 			break;
1036 		}
1037 		snd_unregister_device(devtype, pcm->card, pcm->device);
1038 	}
1039  unlock:
1040 	mutex_unlock(&register_mutex);
1041 	return 0;
1042 }
1043 
1044 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
1045 {
1046 	struct snd_pcm *pcm;
1047 
1048 	if (snd_BUG_ON(!notify ||
1049 		       !notify->n_register ||
1050 		       !notify->n_unregister ||
1051 		       !notify->n_disconnect))
1052 		return -EINVAL;
1053 	mutex_lock(&register_mutex);
1054 	if (nfree) {
1055 		list_del(&notify->list);
1056 		list_for_each_entry(pcm, &snd_pcm_devices, list)
1057 			notify->n_unregister(pcm);
1058 	} else {
1059 		list_add_tail(&notify->list, &snd_pcm_notify_list);
1060 		list_for_each_entry(pcm, &snd_pcm_devices, list)
1061 			notify->n_register(pcm);
1062 	}
1063 	mutex_unlock(&register_mutex);
1064 	return 0;
1065 }
1066 
1067 EXPORT_SYMBOL(snd_pcm_notify);
1068 
1069 #ifdef CONFIG_PROC_FS
1070 /*
1071  *  Info interface
1072  */
1073 
1074 static void snd_pcm_proc_read(struct snd_info_entry *entry,
1075 			      struct snd_info_buffer *buffer)
1076 {
1077 	struct snd_pcm *pcm;
1078 
1079 	mutex_lock(&register_mutex);
1080 	list_for_each_entry(pcm, &snd_pcm_devices, list) {
1081 		snd_iprintf(buffer, "%02i-%02i: %s : %s",
1082 			    pcm->card->number, pcm->device, pcm->id, pcm->name);
1083 		if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
1084 			snd_iprintf(buffer, " : playback %i",
1085 				    pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
1086 		if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
1087 			snd_iprintf(buffer, " : capture %i",
1088 				    pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
1089 		snd_iprintf(buffer, "\n");
1090 	}
1091 	mutex_unlock(&register_mutex);
1092 }
1093 
1094 static struct snd_info_entry *snd_pcm_proc_entry;
1095 
1096 static void snd_pcm_proc_init(void)
1097 {
1098 	struct snd_info_entry *entry;
1099 
1100 	if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
1101 		snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
1102 		if (snd_info_register(entry) < 0) {
1103 			snd_info_free_entry(entry);
1104 			entry = NULL;
1105 		}
1106 	}
1107 	snd_pcm_proc_entry = entry;
1108 }
1109 
1110 static void snd_pcm_proc_done(void)
1111 {
1112 	snd_info_free_entry(snd_pcm_proc_entry);
1113 }
1114 
1115 #else /* !CONFIG_PROC_FS */
1116 #define snd_pcm_proc_init()
1117 #define snd_pcm_proc_done()
1118 #endif /* CONFIG_PROC_FS */
1119 
1120 
1121 /*
1122  *  ENTRY functions
1123  */
1124 
1125 static int __init alsa_pcm_init(void)
1126 {
1127 	snd_ctl_register_ioctl(snd_pcm_control_ioctl);
1128 	snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
1129 	snd_pcm_proc_init();
1130 	return 0;
1131 }
1132 
1133 static void __exit alsa_pcm_exit(void)
1134 {
1135 	snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
1136 	snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
1137 	snd_pcm_proc_done();
1138 }
1139 
1140 module_init(alsa_pcm_init)
1141 module_exit(alsa_pcm_exit)
1142