2 * Digital Audio (PCM) abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
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.
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.
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
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 <linux/nospec.h>
29 #include <sound/core.h>
30 #include <sound/minors.h>
31 #include <sound/pcm.h>
32 #include <sound/timer.h>
33 #include <sound/control.h>
34 #include <sound/info.h>
36 #include "pcm_local.h"
38 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
39 MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
40 MODULE_LICENSE("GPL");
42 static LIST_HEAD(snd_pcm_devices
);
43 static DEFINE_MUTEX(register_mutex
);
44 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
45 static LIST_HEAD(snd_pcm_notify_list
);
48 static int snd_pcm_free(struct snd_pcm
*pcm
);
49 static int snd_pcm_dev_free(struct snd_device
*device
);
50 static int snd_pcm_dev_register(struct snd_device
*device
);
51 static int snd_pcm_dev_disconnect(struct snd_device
*device
);
53 static struct snd_pcm
*snd_pcm_get(struct snd_card
*card
, int device
)
57 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
58 if (pcm
->card
== card
&& pcm
->device
== device
)
64 static int snd_pcm_next(struct snd_card
*card
, int device
)
68 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
69 if (pcm
->card
== card
&& pcm
->device
> device
)
71 else if (pcm
->card
->number
> card
->number
)
77 static int snd_pcm_add(struct snd_pcm
*newpcm
)
84 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
85 if (pcm
->card
== newpcm
->card
&& pcm
->device
== newpcm
->device
)
87 if (pcm
->card
->number
> newpcm
->card
->number
||
88 (pcm
->card
== newpcm
->card
&&
89 pcm
->device
> newpcm
->device
)) {
90 list_add(&newpcm
->list
, pcm
->list
.prev
);
94 list_add_tail(&newpcm
->list
, &snd_pcm_devices
);
98 static int snd_pcm_control_ioctl(struct snd_card
*card
,
99 struct snd_ctl_file
*control
,
100 unsigned int cmd
, unsigned long arg
)
103 case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE
:
107 if (get_user(device
, (int __user
*)arg
))
109 mutex_lock(®ister_mutex
);
110 device
= snd_pcm_next(card
, device
);
111 mutex_unlock(®ister_mutex
);
112 if (put_user(device
, (int __user
*)arg
))
116 case SNDRV_CTL_IOCTL_PCM_INFO
:
118 struct snd_pcm_info __user
*info
;
119 unsigned int device
, subdevice
;
122 struct snd_pcm_str
*pstr
;
123 struct snd_pcm_substream
*substream
;
126 info
= (struct snd_pcm_info __user
*)arg
;
127 if (get_user(device
, &info
->device
))
129 if (get_user(stream
, &info
->stream
))
131 if (stream
< 0 || stream
> 1)
133 stream
= array_index_nospec(stream
, 2);
134 if (get_user(subdevice
, &info
->subdevice
))
136 mutex_lock(®ister_mutex
);
137 pcm
= snd_pcm_get(card
, device
);
142 pstr
= &pcm
->streams
[stream
];
143 if (pstr
->substream_count
== 0) {
147 if (subdevice
>= pstr
->substream_count
) {
151 for (substream
= pstr
->substream
; substream
;
152 substream
= substream
->next
)
153 if (substream
->number
== (int)subdevice
)
155 if (substream
== NULL
) {
159 mutex_lock(&pcm
->open_mutex
);
160 err
= snd_pcm_info_user(substream
, info
);
161 mutex_unlock(&pcm
->open_mutex
);
163 mutex_unlock(®ister_mutex
);
166 case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE
:
170 if (get_user(val
, (int __user
*)arg
))
172 control
->preferred_subdevice
[SND_CTL_SUBDEV_PCM
] = val
;
179 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
181 static char *snd_pcm_format_names
[] = {
200 FORMAT(IEC958_SUBFRAME_LE
),
201 FORMAT(IEC958_SUBFRAME_BE
),
232 * snd_pcm_format_name - Return a name string for the given PCM format
233 * @format: PCM format
235 const char *snd_pcm_format_name(snd_pcm_format_t format
)
237 if ((__force
unsigned int)format
>= ARRAY_SIZE(snd_pcm_format_names
))
239 return snd_pcm_format_names
[(__force
unsigned int)format
];
241 EXPORT_SYMBOL_GPL(snd_pcm_format_name
);
243 #ifdef CONFIG_SND_VERBOSE_PROCFS
245 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
246 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
247 #define READY(v) [SNDRV_PCM_READY_##v] = #v
248 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
249 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
250 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
251 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
252 #define START(v) [SNDRV_PCM_START_##v] = #v
253 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
255 static char *snd_pcm_stream_names
[] = {
260 static char *snd_pcm_state_names
[] = {
271 static char *snd_pcm_access_names
[] = {
272 ACCESS(MMAP_INTERLEAVED
),
273 ACCESS(MMAP_NONINTERLEAVED
),
274 ACCESS(MMAP_COMPLEX
),
275 ACCESS(RW_INTERLEAVED
),
276 ACCESS(RW_NONINTERLEAVED
),
279 static char *snd_pcm_subformat_names
[] = {
283 static char *snd_pcm_tstamp_mode_names
[] = {
288 static const char *snd_pcm_stream_name(int stream
)
290 return snd_pcm_stream_names
[stream
];
293 static const char *snd_pcm_access_name(snd_pcm_access_t access
)
295 return snd_pcm_access_names
[(__force
int)access
];
298 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat
)
300 return snd_pcm_subformat_names
[(__force
int)subformat
];
303 static const char *snd_pcm_tstamp_mode_name(int mode
)
305 return snd_pcm_tstamp_mode_names
[mode
];
308 static const char *snd_pcm_state_name(snd_pcm_state_t state
)
310 return snd_pcm_state_names
[(__force
int)state
];
313 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
314 #include <linux/soundcard.h>
316 static const char *snd_pcm_oss_format_name(int format
)
345 static void snd_pcm_proc_info_read(struct snd_pcm_substream
*substream
,
346 struct snd_info_buffer
*buffer
)
348 struct snd_pcm_info
*info
;
354 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
358 err
= snd_pcm_info(substream
, info
);
360 snd_iprintf(buffer
, "error %d\n", err
);
364 snd_iprintf(buffer
, "card: %d\n", info
->card
);
365 snd_iprintf(buffer
, "device: %d\n", info
->device
);
366 snd_iprintf(buffer
, "subdevice: %d\n", info
->subdevice
);
367 snd_iprintf(buffer
, "stream: %s\n", snd_pcm_stream_name(info
->stream
));
368 snd_iprintf(buffer
, "id: %s\n", info
->id
);
369 snd_iprintf(buffer
, "name: %s\n", info
->name
);
370 snd_iprintf(buffer
, "subname: %s\n", info
->subname
);
371 snd_iprintf(buffer
, "class: %d\n", info
->dev_class
);
372 snd_iprintf(buffer
, "subclass: %d\n", info
->dev_subclass
);
373 snd_iprintf(buffer
, "subdevices_count: %d\n", info
->subdevices_count
);
374 snd_iprintf(buffer
, "subdevices_avail: %d\n", info
->subdevices_avail
);
378 static void snd_pcm_stream_proc_info_read(struct snd_info_entry
*entry
,
379 struct snd_info_buffer
*buffer
)
381 snd_pcm_proc_info_read(((struct snd_pcm_str
*)entry
->private_data
)->substream
,
385 static void snd_pcm_substream_proc_info_read(struct snd_info_entry
*entry
,
386 struct snd_info_buffer
*buffer
)
388 snd_pcm_proc_info_read(entry
->private_data
, buffer
);
391 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry
*entry
,
392 struct snd_info_buffer
*buffer
)
394 struct snd_pcm_substream
*substream
= entry
->private_data
;
395 struct snd_pcm_runtime
*runtime
;
397 mutex_lock(&substream
->pcm
->open_mutex
);
398 runtime
= substream
->runtime
;
400 snd_iprintf(buffer
, "closed\n");
403 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
404 snd_iprintf(buffer
, "no setup\n");
407 snd_iprintf(buffer
, "access: %s\n", snd_pcm_access_name(runtime
->access
));
408 snd_iprintf(buffer
, "format: %s\n", snd_pcm_format_name(runtime
->format
));
409 snd_iprintf(buffer
, "subformat: %s\n", snd_pcm_subformat_name(runtime
->subformat
));
410 snd_iprintf(buffer
, "channels: %u\n", runtime
->channels
);
411 snd_iprintf(buffer
, "rate: %u (%u/%u)\n", runtime
->rate
, runtime
->rate_num
, runtime
->rate_den
);
412 snd_iprintf(buffer
, "period_size: %lu\n", runtime
->period_size
);
413 snd_iprintf(buffer
, "buffer_size: %lu\n", runtime
->buffer_size
);
414 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
415 if (substream
->oss
.oss
) {
416 snd_iprintf(buffer
, "OSS format: %s\n", snd_pcm_oss_format_name(runtime
->oss
.format
));
417 snd_iprintf(buffer
, "OSS channels: %u\n", runtime
->oss
.channels
);
418 snd_iprintf(buffer
, "OSS rate: %u\n", runtime
->oss
.rate
);
419 snd_iprintf(buffer
, "OSS period bytes: %lu\n", (unsigned long)runtime
->oss
.period_bytes
);
420 snd_iprintf(buffer
, "OSS periods: %u\n", runtime
->oss
.periods
);
421 snd_iprintf(buffer
, "OSS period frames: %lu\n", (unsigned long)runtime
->oss
.period_frames
);
425 mutex_unlock(&substream
->pcm
->open_mutex
);
428 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry
*entry
,
429 struct snd_info_buffer
*buffer
)
431 struct snd_pcm_substream
*substream
= entry
->private_data
;
432 struct snd_pcm_runtime
*runtime
;
434 mutex_lock(&substream
->pcm
->open_mutex
);
435 runtime
= substream
->runtime
;
437 snd_iprintf(buffer
, "closed\n");
440 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
441 snd_iprintf(buffer
, "no setup\n");
444 snd_iprintf(buffer
, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime
->tstamp_mode
));
445 snd_iprintf(buffer
, "period_step: %u\n", runtime
->period_step
);
446 snd_iprintf(buffer
, "avail_min: %lu\n", runtime
->control
->avail_min
);
447 snd_iprintf(buffer
, "start_threshold: %lu\n", runtime
->start_threshold
);
448 snd_iprintf(buffer
, "stop_threshold: %lu\n", runtime
->stop_threshold
);
449 snd_iprintf(buffer
, "silence_threshold: %lu\n", runtime
->silence_threshold
);
450 snd_iprintf(buffer
, "silence_size: %lu\n", runtime
->silence_size
);
451 snd_iprintf(buffer
, "boundary: %lu\n", runtime
->boundary
);
453 mutex_unlock(&substream
->pcm
->open_mutex
);
456 static void snd_pcm_substream_proc_status_read(struct snd_info_entry
*entry
,
457 struct snd_info_buffer
*buffer
)
459 struct snd_pcm_substream
*substream
= entry
->private_data
;
460 struct snd_pcm_runtime
*runtime
;
461 struct snd_pcm_status status
;
464 mutex_lock(&substream
->pcm
->open_mutex
);
465 runtime
= substream
->runtime
;
467 snd_iprintf(buffer
, "closed\n");
470 memset(&status
, 0, sizeof(status
));
471 err
= snd_pcm_status(substream
, &status
);
473 snd_iprintf(buffer
, "error %d\n", err
);
476 snd_iprintf(buffer
, "state: %s\n", snd_pcm_state_name(status
.state
));
477 snd_iprintf(buffer
, "owner_pid : %d\n", pid_vnr(substream
->pid
));
478 snd_iprintf(buffer
, "trigger_time: %ld.%09ld\n",
479 status
.trigger_tstamp
.tv_sec
, status
.trigger_tstamp
.tv_nsec
);
480 snd_iprintf(buffer
, "tstamp : %ld.%09ld\n",
481 status
.tstamp
.tv_sec
, status
.tstamp
.tv_nsec
);
482 snd_iprintf(buffer
, "delay : %ld\n", status
.delay
);
483 snd_iprintf(buffer
, "avail : %ld\n", status
.avail
);
484 snd_iprintf(buffer
, "avail_max : %ld\n", status
.avail_max
);
485 snd_iprintf(buffer
, "-----\n");
486 snd_iprintf(buffer
, "hw_ptr : %ld\n", runtime
->status
->hw_ptr
);
487 snd_iprintf(buffer
, "appl_ptr : %ld\n", runtime
->control
->appl_ptr
);
489 mutex_unlock(&substream
->pcm
->open_mutex
);
492 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
493 static void snd_pcm_xrun_injection_write(struct snd_info_entry
*entry
,
494 struct snd_info_buffer
*buffer
)
496 struct snd_pcm_substream
*substream
= entry
->private_data
;
497 struct snd_pcm_runtime
*runtime
;
499 snd_pcm_stream_lock_irq(substream
);
500 runtime
= substream
->runtime
;
501 if (runtime
&& runtime
->status
->state
== SNDRV_PCM_STATE_RUNNING
)
502 snd_pcm_stop(substream
, SNDRV_PCM_STATE_XRUN
);
503 snd_pcm_stream_unlock_irq(substream
);
506 static void snd_pcm_xrun_debug_read(struct snd_info_entry
*entry
,
507 struct snd_info_buffer
*buffer
)
509 struct snd_pcm_str
*pstr
= entry
->private_data
;
510 snd_iprintf(buffer
, "%d\n", pstr
->xrun_debug
);
513 static void snd_pcm_xrun_debug_write(struct snd_info_entry
*entry
,
514 struct snd_info_buffer
*buffer
)
516 struct snd_pcm_str
*pstr
= entry
->private_data
;
518 if (!snd_info_get_line(buffer
, line
, sizeof(line
)))
519 pstr
->xrun_debug
= simple_strtoul(line
, NULL
, 10);
523 static int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
)
525 struct snd_pcm
*pcm
= pstr
->pcm
;
526 struct snd_info_entry
*entry
;
529 sprintf(name
, "pcm%i%c", pcm
->device
,
530 pstr
->stream
== SNDRV_PCM_STREAM_PLAYBACK
? 'p' : 'c');
531 entry
= snd_info_create_card_entry(pcm
->card
, name
,
532 pcm
->card
->proc_root
);
535 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
536 if (snd_info_register(entry
) < 0) {
537 snd_info_free_entry(entry
);
540 pstr
->proc_root
= entry
;
541 entry
= snd_info_create_card_entry(pcm
->card
, "info", pstr
->proc_root
);
543 snd_info_set_text_ops(entry
, pstr
, snd_pcm_stream_proc_info_read
);
544 if (snd_info_register(entry
) < 0) {
545 snd_info_free_entry(entry
);
549 pstr
->proc_info_entry
= entry
;
551 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
552 entry
= snd_info_create_card_entry(pcm
->card
, "xrun_debug",
555 entry
->c
.text
.read
= snd_pcm_xrun_debug_read
;
556 entry
->c
.text
.write
= snd_pcm_xrun_debug_write
;
557 entry
->mode
|= S_IWUSR
;
558 entry
->private_data
= pstr
;
559 if (snd_info_register(entry
) < 0) {
560 snd_info_free_entry(entry
);
564 pstr
->proc_xrun_debug_entry
= entry
;
569 static int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
)
571 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
572 snd_info_free_entry(pstr
->proc_xrun_debug_entry
);
573 pstr
->proc_xrun_debug_entry
= NULL
;
575 snd_info_free_entry(pstr
->proc_info_entry
);
576 pstr
->proc_info_entry
= NULL
;
577 snd_info_free_entry(pstr
->proc_root
);
578 pstr
->proc_root
= NULL
;
582 static int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
)
584 struct snd_info_entry
*entry
;
585 struct snd_card
*card
;
588 card
= substream
->pcm
->card
;
590 sprintf(name
, "sub%i", substream
->number
);
591 entry
= snd_info_create_card_entry(card
, name
,
592 substream
->pstr
->proc_root
);
595 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
596 if (snd_info_register(entry
) < 0) {
597 snd_info_free_entry(entry
);
600 substream
->proc_root
= entry
;
601 entry
= snd_info_create_card_entry(card
, "info", substream
->proc_root
);
603 snd_info_set_text_ops(entry
, substream
,
604 snd_pcm_substream_proc_info_read
);
605 if (snd_info_register(entry
) < 0) {
606 snd_info_free_entry(entry
);
610 substream
->proc_info_entry
= entry
;
611 entry
= snd_info_create_card_entry(card
, "hw_params",
612 substream
->proc_root
);
614 snd_info_set_text_ops(entry
, substream
,
615 snd_pcm_substream_proc_hw_params_read
);
616 if (snd_info_register(entry
) < 0) {
617 snd_info_free_entry(entry
);
621 substream
->proc_hw_params_entry
= entry
;
622 entry
= snd_info_create_card_entry(card
, "sw_params",
623 substream
->proc_root
);
625 snd_info_set_text_ops(entry
, substream
,
626 snd_pcm_substream_proc_sw_params_read
);
627 if (snd_info_register(entry
) < 0) {
628 snd_info_free_entry(entry
);
632 substream
->proc_sw_params_entry
= entry
;
633 entry
= snd_info_create_card_entry(card
, "status",
634 substream
->proc_root
);
636 snd_info_set_text_ops(entry
, substream
,
637 snd_pcm_substream_proc_status_read
);
638 if (snd_info_register(entry
) < 0) {
639 snd_info_free_entry(entry
);
643 substream
->proc_status_entry
= entry
;
645 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
646 entry
= snd_info_create_card_entry(card
, "xrun_injection",
647 substream
->proc_root
);
649 entry
->private_data
= substream
;
650 entry
->c
.text
.read
= NULL
;
651 entry
->c
.text
.write
= snd_pcm_xrun_injection_write
;
652 entry
->mode
= S_IFREG
| S_IWUSR
;
653 if (snd_info_register(entry
) < 0) {
654 snd_info_free_entry(entry
);
658 substream
->proc_xrun_injection_entry
= entry
;
659 #endif /* CONFIG_SND_PCM_XRUN_DEBUG */
664 static int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
)
666 snd_info_free_entry(substream
->proc_info_entry
);
667 substream
->proc_info_entry
= NULL
;
668 snd_info_free_entry(substream
->proc_hw_params_entry
);
669 substream
->proc_hw_params_entry
= NULL
;
670 snd_info_free_entry(substream
->proc_sw_params_entry
);
671 substream
->proc_sw_params_entry
= NULL
;
672 snd_info_free_entry(substream
->proc_status_entry
);
673 substream
->proc_status_entry
= NULL
;
674 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
675 snd_info_free_entry(substream
->proc_xrun_injection_entry
);
676 substream
->proc_xrun_injection_entry
= NULL
;
678 snd_info_free_entry(substream
->proc_root
);
679 substream
->proc_root
= NULL
;
682 #else /* !CONFIG_SND_VERBOSE_PROCFS */
683 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
) { return 0; }
684 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
) { return 0; }
685 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
) { return 0; }
686 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
) { return 0; }
687 #endif /* CONFIG_SND_VERBOSE_PROCFS */
689 static const struct attribute_group
*pcm_dev_attr_groups
[];
692 * snd_pcm_new_stream - create a new PCM stream
693 * @pcm: the pcm instance
694 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
695 * @substream_count: the number of substreams
697 * Creates a new stream for the pcm.
698 * The corresponding stream on the pcm must have been empty before
699 * calling this, i.e. zero must be given to the argument of
702 * Return: Zero if successful, or a negative error code on failure.
704 int snd_pcm_new_stream(struct snd_pcm
*pcm
, int stream
, int substream_count
)
707 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
708 struct snd_pcm_substream
*substream
, *prev
;
710 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
711 mutex_init(&pstr
->oss
.setup_mutex
);
713 pstr
->stream
= stream
;
715 pstr
->substream_count
= substream_count
;
716 if (!substream_count
)
719 snd_device_initialize(&pstr
->dev
, pcm
->card
);
720 pstr
->dev
.groups
= pcm_dev_attr_groups
;
721 dev_set_name(&pstr
->dev
, "pcmC%iD%i%c", pcm
->card
->number
, pcm
->device
,
722 stream
== SNDRV_PCM_STREAM_PLAYBACK
? 'p' : 'c');
724 if (!pcm
->internal
) {
725 err
= snd_pcm_stream_proc_init(pstr
);
727 pcm_err(pcm
, "Error in snd_pcm_stream_proc_init\n");
732 for (idx
= 0, prev
= NULL
; idx
< substream_count
; idx
++) {
733 substream
= kzalloc(sizeof(*substream
), GFP_KERNEL
);
736 substream
->pcm
= pcm
;
737 substream
->pstr
= pstr
;
738 substream
->number
= idx
;
739 substream
->stream
= stream
;
740 sprintf(substream
->name
, "subdevice #%i", idx
);
741 substream
->buffer_bytes_max
= UINT_MAX
;
743 pstr
->substream
= substream
;
745 prev
->next
= substream
;
747 if (!pcm
->internal
) {
748 err
= snd_pcm_substream_proc_init(substream
);
751 "Error in snd_pcm_stream_proc_init\n");
753 pstr
->substream
= NULL
;
760 substream
->group
= &substream
->self_group
;
761 spin_lock_init(&substream
->self_group
.lock
);
762 mutex_init(&substream
->self_group
.mutex
);
763 INIT_LIST_HEAD(&substream
->self_group
.substreams
);
764 list_add_tail(&substream
->link_list
, &substream
->self_group
.substreams
);
765 atomic_set(&substream
->mmap_count
, 0);
770 EXPORT_SYMBOL(snd_pcm_new_stream
);
772 static int _snd_pcm_new(struct snd_card
*card
, const char *id
, int device
,
773 int playback_count
, int capture_count
, bool internal
,
774 struct snd_pcm
**rpcm
)
778 static struct snd_device_ops ops
= {
779 .dev_free
= snd_pcm_dev_free
,
780 .dev_register
= snd_pcm_dev_register
,
781 .dev_disconnect
= snd_pcm_dev_disconnect
,
783 static struct snd_device_ops internal_ops
= {
784 .dev_free
= snd_pcm_dev_free
,
787 if (snd_BUG_ON(!card
))
791 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
795 pcm
->device
= device
;
796 pcm
->internal
= internal
;
797 mutex_init(&pcm
->open_mutex
);
798 init_waitqueue_head(&pcm
->open_wait
);
799 INIT_LIST_HEAD(&pcm
->list
);
801 strlcpy(pcm
->id
, id
, sizeof(pcm
->id
));
803 err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
808 err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_CAPTURE
, capture_count
);
812 err
= snd_device_new(card
, SNDRV_DEV_PCM
, pcm
,
813 internal
? &internal_ops
: &ops
);
827 * snd_pcm_new - create a new PCM instance
828 * @card: the card instance
830 * @device: the device index (zero based)
831 * @playback_count: the number of substreams for playback
832 * @capture_count: the number of substreams for capture
833 * @rpcm: the pointer to store the new pcm instance
835 * Creates a new PCM instance.
837 * The pcm operators have to be set afterwards to the new instance
838 * via snd_pcm_set_ops().
840 * Return: Zero if successful, or a negative error code on failure.
842 int snd_pcm_new(struct snd_card
*card
, const char *id
, int device
,
843 int playback_count
, int capture_count
, struct snd_pcm
**rpcm
)
845 return _snd_pcm_new(card
, id
, device
, playback_count
, capture_count
,
848 EXPORT_SYMBOL(snd_pcm_new
);
851 * snd_pcm_new_internal - create a new internal PCM instance
852 * @card: the card instance
854 * @device: the device index (zero based - shared with normal PCMs)
855 * @playback_count: the number of substreams for playback
856 * @capture_count: the number of substreams for capture
857 * @rpcm: the pointer to store the new pcm instance
859 * Creates a new internal PCM instance with no userspace device or procfs
860 * entries. This is used by ASoC Back End PCMs in order to create a PCM that
861 * will only be used internally by kernel drivers. i.e. it cannot be opened
862 * by userspace. It provides existing ASoC components drivers with a substream
863 * and access to any private data.
865 * The pcm operators have to be set afterwards to the new instance
866 * via snd_pcm_set_ops().
868 * Return: Zero if successful, or a negative error code on failure.
870 int snd_pcm_new_internal(struct snd_card
*card
, const char *id
, int device
,
871 int playback_count
, int capture_count
,
872 struct snd_pcm
**rpcm
)
874 return _snd_pcm_new(card
, id
, device
, playback_count
, capture_count
,
877 EXPORT_SYMBOL(snd_pcm_new_internal
);
879 static void free_chmap(struct snd_pcm_str
*pstr
)
881 if (pstr
->chmap_kctl
) {
882 snd_ctl_remove(pstr
->pcm
->card
, pstr
->chmap_kctl
);
883 pstr
->chmap_kctl
= NULL
;
887 static void snd_pcm_free_stream(struct snd_pcm_str
* pstr
)
889 struct snd_pcm_substream
*substream
, *substream_next
;
890 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
891 struct snd_pcm_oss_setup
*setup
, *setupn
;
893 substream
= pstr
->substream
;
895 substream_next
= substream
->next
;
896 snd_pcm_timer_done(substream
);
897 snd_pcm_substream_proc_done(substream
);
899 substream
= substream_next
;
901 snd_pcm_stream_proc_done(pstr
);
902 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
903 for (setup
= pstr
->oss
.setup_list
; setup
; setup
= setupn
) {
904 setupn
= setup
->next
;
905 kfree(setup
->task_name
);
910 if (pstr
->substream_count
)
911 put_device(&pstr
->dev
);
914 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
915 #define pcm_call_notify(pcm, call) \
917 struct snd_pcm_notify *_notify; \
918 list_for_each_entry(_notify, &snd_pcm_notify_list, list) \
919 _notify->call(pcm); \
922 #define pcm_call_notify(pcm, call) do {} while (0)
925 static int snd_pcm_free(struct snd_pcm
*pcm
)
930 pcm_call_notify(pcm
, n_unregister
);
931 if (pcm
->private_free
)
932 pcm
->private_free(pcm
);
933 snd_pcm_lib_preallocate_free_for_all(pcm
);
934 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]);
935 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
]);
940 static int snd_pcm_dev_free(struct snd_device
*device
)
942 struct snd_pcm
*pcm
= device
->device_data
;
943 return snd_pcm_free(pcm
);
946 int snd_pcm_attach_substream(struct snd_pcm
*pcm
, int stream
,
948 struct snd_pcm_substream
**rsubstream
)
950 struct snd_pcm_str
* pstr
;
951 struct snd_pcm_substream
*substream
;
952 struct snd_pcm_runtime
*runtime
;
953 struct snd_card
*card
;
954 int prefer_subdevice
;
957 if (snd_BUG_ON(!pcm
|| !rsubstream
))
959 if (snd_BUG_ON(stream
!= SNDRV_PCM_STREAM_PLAYBACK
&&
960 stream
!= SNDRV_PCM_STREAM_CAPTURE
))
963 pstr
= &pcm
->streams
[stream
];
964 if (pstr
->substream
== NULL
|| pstr
->substream_count
== 0)
968 prefer_subdevice
= snd_ctl_get_preferred_subdevice(card
, SND_CTL_SUBDEV_PCM
);
970 if (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
) {
971 int opposite
= !stream
;
973 for (substream
= pcm
->streams
[opposite
].substream
; substream
;
974 substream
= substream
->next
) {
975 if (SUBSTREAM_BUSY(substream
))
980 if (file
->f_flags
& O_APPEND
) {
981 if (prefer_subdevice
< 0) {
982 if (pstr
->substream_count
> 1)
983 return -EINVAL
; /* must be unique */
984 substream
= pstr
->substream
;
986 for (substream
= pstr
->substream
; substream
;
987 substream
= substream
->next
)
988 if (substream
->number
== prefer_subdevice
)
993 if (! SUBSTREAM_BUSY(substream
))
995 substream
->ref_count
++;
996 *rsubstream
= substream
;
1000 for (substream
= pstr
->substream
; substream
; substream
= substream
->next
) {
1001 if (!SUBSTREAM_BUSY(substream
) &&
1002 (prefer_subdevice
== -1 ||
1003 substream
->number
== prefer_subdevice
))
1006 if (substream
== NULL
)
1009 runtime
= kzalloc(sizeof(*runtime
), GFP_KERNEL
);
1010 if (runtime
== NULL
)
1013 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
));
1014 runtime
->status
= snd_malloc_pages(size
, GFP_KERNEL
);
1015 if (runtime
->status
== NULL
) {
1019 memset((void*)runtime
->status
, 0, size
);
1021 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
));
1022 runtime
->control
= snd_malloc_pages(size
, GFP_KERNEL
);
1023 if (runtime
->control
== NULL
) {
1024 snd_free_pages((void*)runtime
->status
,
1025 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
1029 memset((void*)runtime
->control
, 0, size
);
1031 init_waitqueue_head(&runtime
->sleep
);
1032 init_waitqueue_head(&runtime
->tsleep
);
1034 runtime
->status
->state
= SNDRV_PCM_STATE_OPEN
;
1036 substream
->runtime
= runtime
;
1037 substream
->private_data
= pcm
->private_data
;
1038 substream
->ref_count
= 1;
1039 substream
->f_flags
= file
->f_flags
;
1040 substream
->pid
= get_pid(task_pid(current
));
1041 pstr
->substream_opened
++;
1042 *rsubstream
= substream
;
1046 void snd_pcm_detach_substream(struct snd_pcm_substream
*substream
)
1048 struct snd_pcm_runtime
*runtime
;
1050 if (PCM_RUNTIME_CHECK(substream
))
1052 runtime
= substream
->runtime
;
1053 if (runtime
->private_free
!= NULL
)
1054 runtime
->private_free(runtime
);
1055 snd_free_pages((void*)runtime
->status
,
1056 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
1057 snd_free_pages((void*)runtime
->control
,
1058 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
)));
1059 kfree(runtime
->hw_constraints
.rules
);
1060 /* Avoid concurrent access to runtime via PCM timer interface */
1061 if (substream
->timer
)
1062 spin_lock_irq(&substream
->timer
->lock
);
1063 substream
->runtime
= NULL
;
1064 if (substream
->timer
)
1065 spin_unlock_irq(&substream
->timer
->lock
);
1067 put_pid(substream
->pid
);
1068 substream
->pid
= NULL
;
1069 substream
->pstr
->substream_opened
--;
1072 static ssize_t
show_pcm_class(struct device
*dev
,
1073 struct device_attribute
*attr
, char *buf
)
1075 struct snd_pcm_str
*pstr
= container_of(dev
, struct snd_pcm_str
, dev
);
1076 struct snd_pcm
*pcm
= pstr
->pcm
;
1078 static const char *strs
[SNDRV_PCM_CLASS_LAST
+ 1] = {
1079 [SNDRV_PCM_CLASS_GENERIC
] = "generic",
1080 [SNDRV_PCM_CLASS_MULTI
] = "multi",
1081 [SNDRV_PCM_CLASS_MODEM
] = "modem",
1082 [SNDRV_PCM_CLASS_DIGITIZER
] = "digitizer",
1085 if (pcm
->dev_class
> SNDRV_PCM_CLASS_LAST
)
1088 str
= strs
[pcm
->dev_class
];
1089 return snprintf(buf
, PAGE_SIZE
, "%s\n", str
);
1092 static DEVICE_ATTR(pcm_class
, S_IRUGO
, show_pcm_class
, NULL
);
1093 static struct attribute
*pcm_dev_attrs
[] = {
1094 &dev_attr_pcm_class
.attr
,
1098 static const struct attribute_group pcm_dev_attr_group
= {
1099 .attrs
= pcm_dev_attrs
,
1102 static const struct attribute_group
*pcm_dev_attr_groups
[] = {
1103 &pcm_dev_attr_group
,
1107 static int snd_pcm_dev_register(struct snd_device
*device
)
1110 struct snd_pcm_substream
*substream
;
1111 struct snd_pcm
*pcm
;
1113 if (snd_BUG_ON(!device
|| !device
->device_data
))
1115 pcm
= device
->device_data
;
1117 mutex_lock(®ister_mutex
);
1118 err
= snd_pcm_add(pcm
);
1121 for (cidx
= 0; cidx
< 2; cidx
++) {
1123 if (pcm
->streams
[cidx
].substream
== NULL
)
1126 case SNDRV_PCM_STREAM_PLAYBACK
:
1127 devtype
= SNDRV_DEVICE_TYPE_PCM_PLAYBACK
;
1129 case SNDRV_PCM_STREAM_CAPTURE
:
1130 devtype
= SNDRV_DEVICE_TYPE_PCM_CAPTURE
;
1134 err
= snd_register_device(devtype
, pcm
->card
, pcm
->device
,
1135 &snd_pcm_f_ops
[cidx
], pcm
,
1136 &pcm
->streams
[cidx
].dev
);
1138 list_del_init(&pcm
->list
);
1142 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
)
1143 snd_pcm_timer_init(substream
);
1146 pcm_call_notify(pcm
, n_register
);
1149 mutex_unlock(®ister_mutex
);
1153 static int snd_pcm_dev_disconnect(struct snd_device
*device
)
1155 struct snd_pcm
*pcm
= device
->device_data
;
1156 struct snd_pcm_substream
*substream
;
1159 mutex_lock(®ister_mutex
);
1160 mutex_lock(&pcm
->open_mutex
);
1161 wake_up(&pcm
->open_wait
);
1162 list_del_init(&pcm
->list
);
1163 for (cidx
= 0; cidx
< 2; cidx
++) {
1164 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
) {
1165 snd_pcm_stream_lock_irq(substream
);
1166 if (substream
->runtime
) {
1167 if (snd_pcm_running(substream
))
1168 snd_pcm_stop(substream
,
1169 SNDRV_PCM_STATE_DISCONNECTED
);
1170 /* to be sure, set the state unconditionally */
1171 substream
->runtime
->status
->state
= SNDRV_PCM_STATE_DISCONNECTED
;
1172 wake_up(&substream
->runtime
->sleep
);
1173 wake_up(&substream
->runtime
->tsleep
);
1175 snd_pcm_stream_unlock_irq(substream
);
1179 pcm_call_notify(pcm
, n_disconnect
);
1180 for (cidx
= 0; cidx
< 2; cidx
++) {
1181 snd_unregister_device(&pcm
->streams
[cidx
].dev
);
1182 free_chmap(&pcm
->streams
[cidx
]);
1184 mutex_unlock(&pcm
->open_mutex
);
1185 mutex_unlock(®ister_mutex
);
1189 #if IS_ENABLED(CONFIG_SND_PCM_OSS)
1191 * snd_pcm_notify - Add/remove the notify list
1192 * @notify: PCM notify list
1193 * @nfree: 0 = register, 1 = unregister
1195 * This adds the given notifier to the global list so that the callback is
1196 * called for each registered PCM devices. This exists only for PCM OSS
1197 * emulation, so far.
1199 int snd_pcm_notify(struct snd_pcm_notify
*notify
, int nfree
)
1201 struct snd_pcm
*pcm
;
1203 if (snd_BUG_ON(!notify
||
1204 !notify
->n_register
||
1205 !notify
->n_unregister
||
1206 !notify
->n_disconnect
))
1208 mutex_lock(®ister_mutex
);
1210 list_del(¬ify
->list
);
1211 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1212 notify
->n_unregister(pcm
);
1214 list_add_tail(¬ify
->list
, &snd_pcm_notify_list
);
1215 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1216 notify
->n_register(pcm
);
1218 mutex_unlock(®ister_mutex
);
1221 EXPORT_SYMBOL(snd_pcm_notify
);
1222 #endif /* CONFIG_SND_PCM_OSS */
1224 #ifdef CONFIG_SND_PROC_FS
1229 static void snd_pcm_proc_read(struct snd_info_entry
*entry
,
1230 struct snd_info_buffer
*buffer
)
1232 struct snd_pcm
*pcm
;
1234 mutex_lock(®ister_mutex
);
1235 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
1236 snd_iprintf(buffer
, "%02i-%02i: %s : %s",
1237 pcm
->card
->number
, pcm
->device
, pcm
->id
, pcm
->name
);
1238 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
)
1239 snd_iprintf(buffer
, " : playback %i",
1240 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream_count
);
1241 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
)
1242 snd_iprintf(buffer
, " : capture %i",
1243 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
);
1244 snd_iprintf(buffer
, "\n");
1246 mutex_unlock(®ister_mutex
);
1249 static struct snd_info_entry
*snd_pcm_proc_entry
;
1251 static void snd_pcm_proc_init(void)
1253 struct snd_info_entry
*entry
;
1255 entry
= snd_info_create_module_entry(THIS_MODULE
, "pcm", NULL
);
1257 snd_info_set_text_ops(entry
, NULL
, snd_pcm_proc_read
);
1258 if (snd_info_register(entry
) < 0) {
1259 snd_info_free_entry(entry
);
1263 snd_pcm_proc_entry
= entry
;
1266 static void snd_pcm_proc_done(void)
1268 snd_info_free_entry(snd_pcm_proc_entry
);
1271 #else /* !CONFIG_SND_PROC_FS */
1272 #define snd_pcm_proc_init()
1273 #define snd_pcm_proc_done()
1274 #endif /* CONFIG_SND_PROC_FS */
1281 static int __init
alsa_pcm_init(void)
1283 snd_ctl_register_ioctl(snd_pcm_control_ioctl
);
1284 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl
);
1285 snd_pcm_proc_init();
1289 static void __exit
alsa_pcm_exit(void)
1291 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl
);
1292 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl
);
1293 snd_pcm_proc_done();
1296 module_init(alsa_pcm_init
)
1297 module_exit(alsa_pcm_exit
)