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