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 <sound/core.h>
29 #include <sound/minors.h>
30 #include <sound/pcm.h>
31 #include <sound/control.h>
32 #include <sound/info.h>
34 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
35 MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
36 MODULE_LICENSE("GPL");
38 static LIST_HEAD(snd_pcm_devices
);
39 static LIST_HEAD(snd_pcm_notify_list
);
40 static DEFINE_MUTEX(register_mutex
);
42 static int snd_pcm_free(struct snd_pcm
*pcm
);
43 static int snd_pcm_dev_free(struct snd_device
*device
);
44 static int snd_pcm_dev_register(struct snd_device
*device
);
45 static int snd_pcm_dev_disconnect(struct snd_device
*device
);
47 static struct snd_pcm
*snd_pcm_get(struct snd_card
*card
, int device
)
51 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
52 if (pcm
->card
== card
&& pcm
->device
== device
)
58 static int snd_pcm_next(struct snd_card
*card
, int device
)
62 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
63 if (pcm
->card
== card
&& pcm
->device
> device
)
65 else if (pcm
->card
->number
> card
->number
)
71 static int snd_pcm_add(struct snd_pcm
*newpcm
)
75 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
76 if (pcm
->card
== newpcm
->card
&& pcm
->device
== newpcm
->device
)
78 if (pcm
->card
->number
> newpcm
->card
->number
||
79 (pcm
->card
== newpcm
->card
&&
80 pcm
->device
> newpcm
->device
)) {
81 list_add(&newpcm
->list
, pcm
->list
.prev
);
85 list_add_tail(&newpcm
->list
, &snd_pcm_devices
);
89 static int snd_pcm_control_ioctl(struct snd_card
*card
,
90 struct snd_ctl_file
*control
,
91 unsigned int cmd
, unsigned long arg
)
94 case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE
:
98 if (get_user(device
, (int __user
*)arg
))
100 mutex_lock(®ister_mutex
);
101 device
= snd_pcm_next(card
, device
);
102 mutex_unlock(®ister_mutex
);
103 if (put_user(device
, (int __user
*)arg
))
107 case SNDRV_CTL_IOCTL_PCM_INFO
:
109 struct snd_pcm_info __user
*info
;
110 unsigned int device
, subdevice
;
113 struct snd_pcm_str
*pstr
;
114 struct snd_pcm_substream
*substream
;
117 info
= (struct snd_pcm_info __user
*)arg
;
118 if (get_user(device
, &info
->device
))
120 if (get_user(stream
, &info
->stream
))
122 if (stream
< 0 || stream
> 1)
124 if (get_user(subdevice
, &info
->subdevice
))
126 mutex_lock(®ister_mutex
);
127 pcm
= snd_pcm_get(card
, device
);
132 pstr
= &pcm
->streams
[stream
];
133 if (pstr
->substream_count
== 0) {
137 if (subdevice
>= pstr
->substream_count
) {
141 for (substream
= pstr
->substream
; substream
;
142 substream
= substream
->next
)
143 if (substream
->number
== (int)subdevice
)
145 if (substream
== NULL
) {
149 err
= snd_pcm_info_user(substream
, info
);
151 mutex_unlock(®ister_mutex
);
154 case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE
:
158 if (get_user(val
, (int __user
*)arg
))
160 control
->prefer_pcm_subdevice
= val
;
167 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
169 static char *snd_pcm_format_names
[] = {
188 FORMAT(IEC958_SUBFRAME_LE
),
189 FORMAT(IEC958_SUBFRAME_BE
),
216 const char *snd_pcm_format_name(snd_pcm_format_t format
)
218 if ((__force
unsigned int)format
>= ARRAY_SIZE(snd_pcm_format_names
))
220 return snd_pcm_format_names
[(__force
unsigned int)format
];
222 EXPORT_SYMBOL_GPL(snd_pcm_format_name
);
224 #ifdef CONFIG_SND_VERBOSE_PROCFS
226 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
227 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
228 #define READY(v) [SNDRV_PCM_READY_##v] = #v
229 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
230 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
231 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
232 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
233 #define START(v) [SNDRV_PCM_START_##v] = #v
234 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
236 static char *snd_pcm_stream_names
[] = {
241 static char *snd_pcm_state_names
[] = {
252 static char *snd_pcm_access_names
[] = {
253 ACCESS(MMAP_INTERLEAVED
),
254 ACCESS(MMAP_NONINTERLEAVED
),
255 ACCESS(MMAP_COMPLEX
),
256 ACCESS(RW_INTERLEAVED
),
257 ACCESS(RW_NONINTERLEAVED
),
260 static char *snd_pcm_subformat_names
[] = {
264 static char *snd_pcm_tstamp_mode_names
[] = {
269 static const char *snd_pcm_stream_name(int stream
)
271 return snd_pcm_stream_names
[stream
];
274 static const char *snd_pcm_access_name(snd_pcm_access_t access
)
276 return snd_pcm_access_names
[(__force
int)access
];
279 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat
)
281 return snd_pcm_subformat_names
[(__force
int)subformat
];
284 static const char *snd_pcm_tstamp_mode_name(int mode
)
286 return snd_pcm_tstamp_mode_names
[mode
];
289 static const char *snd_pcm_state_name(snd_pcm_state_t state
)
291 return snd_pcm_state_names
[(__force
int)state
];
294 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
295 #include <linux/soundcard.h>
297 static const char *snd_pcm_oss_format_name(int format
)
326 static void snd_pcm_proc_info_read(struct snd_pcm_substream
*substream
,
327 struct snd_info_buffer
*buffer
)
329 struct snd_pcm_info
*info
;
335 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
337 printk(KERN_DEBUG
"snd_pcm_proc_info_read: cannot malloc\n");
341 err
= snd_pcm_info(substream
, info
);
343 snd_iprintf(buffer
, "error %d\n", err
);
347 snd_iprintf(buffer
, "card: %d\n", info
->card
);
348 snd_iprintf(buffer
, "device: %d\n", info
->device
);
349 snd_iprintf(buffer
, "subdevice: %d\n", info
->subdevice
);
350 snd_iprintf(buffer
, "stream: %s\n", snd_pcm_stream_name(info
->stream
));
351 snd_iprintf(buffer
, "id: %s\n", info
->id
);
352 snd_iprintf(buffer
, "name: %s\n", info
->name
);
353 snd_iprintf(buffer
, "subname: %s\n", info
->subname
);
354 snd_iprintf(buffer
, "class: %d\n", info
->dev_class
);
355 snd_iprintf(buffer
, "subclass: %d\n", info
->dev_subclass
);
356 snd_iprintf(buffer
, "subdevices_count: %d\n", info
->subdevices_count
);
357 snd_iprintf(buffer
, "subdevices_avail: %d\n", info
->subdevices_avail
);
361 static void snd_pcm_stream_proc_info_read(struct snd_info_entry
*entry
,
362 struct snd_info_buffer
*buffer
)
364 snd_pcm_proc_info_read(((struct snd_pcm_str
*)entry
->private_data
)->substream
,
368 static void snd_pcm_substream_proc_info_read(struct snd_info_entry
*entry
,
369 struct snd_info_buffer
*buffer
)
371 snd_pcm_proc_info_read(entry
->private_data
, buffer
);
374 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry
*entry
,
375 struct snd_info_buffer
*buffer
)
377 struct snd_pcm_substream
*substream
= entry
->private_data
;
378 struct snd_pcm_runtime
*runtime
;
380 mutex_lock(&substream
->pcm
->open_mutex
);
381 runtime
= substream
->runtime
;
383 snd_iprintf(buffer
, "closed\n");
386 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
387 snd_iprintf(buffer
, "no setup\n");
390 snd_iprintf(buffer
, "access: %s\n", snd_pcm_access_name(runtime
->access
));
391 snd_iprintf(buffer
, "format: %s\n", snd_pcm_format_name(runtime
->format
));
392 snd_iprintf(buffer
, "subformat: %s\n", snd_pcm_subformat_name(runtime
->subformat
));
393 snd_iprintf(buffer
, "channels: %u\n", runtime
->channels
);
394 snd_iprintf(buffer
, "rate: %u (%u/%u)\n", runtime
->rate
, runtime
->rate_num
, runtime
->rate_den
);
395 snd_iprintf(buffer
, "period_size: %lu\n", runtime
->period_size
);
396 snd_iprintf(buffer
, "buffer_size: %lu\n", runtime
->buffer_size
);
397 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
398 if (substream
->oss
.oss
) {
399 snd_iprintf(buffer
, "OSS format: %s\n", snd_pcm_oss_format_name(runtime
->oss
.format
));
400 snd_iprintf(buffer
, "OSS channels: %u\n", runtime
->oss
.channels
);
401 snd_iprintf(buffer
, "OSS rate: %u\n", runtime
->oss
.rate
);
402 snd_iprintf(buffer
, "OSS period bytes: %lu\n", (unsigned long)runtime
->oss
.period_bytes
);
403 snd_iprintf(buffer
, "OSS periods: %u\n", runtime
->oss
.periods
);
404 snd_iprintf(buffer
, "OSS period frames: %lu\n", (unsigned long)runtime
->oss
.period_frames
);
408 mutex_unlock(&substream
->pcm
->open_mutex
);
411 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry
*entry
,
412 struct snd_info_buffer
*buffer
)
414 struct snd_pcm_substream
*substream
= entry
->private_data
;
415 struct snd_pcm_runtime
*runtime
;
417 mutex_lock(&substream
->pcm
->open_mutex
);
418 runtime
= substream
->runtime
;
420 snd_iprintf(buffer
, "closed\n");
423 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
424 snd_iprintf(buffer
, "no setup\n");
427 snd_iprintf(buffer
, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime
->tstamp_mode
));
428 snd_iprintf(buffer
, "period_step: %u\n", runtime
->period_step
);
429 snd_iprintf(buffer
, "avail_min: %lu\n", runtime
->control
->avail_min
);
430 snd_iprintf(buffer
, "start_threshold: %lu\n", runtime
->start_threshold
);
431 snd_iprintf(buffer
, "stop_threshold: %lu\n", runtime
->stop_threshold
);
432 snd_iprintf(buffer
, "silence_threshold: %lu\n", runtime
->silence_threshold
);
433 snd_iprintf(buffer
, "silence_size: %lu\n", runtime
->silence_size
);
434 snd_iprintf(buffer
, "boundary: %lu\n", runtime
->boundary
);
436 mutex_unlock(&substream
->pcm
->open_mutex
);
439 static void snd_pcm_substream_proc_status_read(struct snd_info_entry
*entry
,
440 struct snd_info_buffer
*buffer
)
442 struct snd_pcm_substream
*substream
= entry
->private_data
;
443 struct snd_pcm_runtime
*runtime
;
444 struct snd_pcm_status status
;
447 mutex_lock(&substream
->pcm
->open_mutex
);
448 runtime
= substream
->runtime
;
450 snd_iprintf(buffer
, "closed\n");
453 memset(&status
, 0, sizeof(status
));
454 err
= snd_pcm_status(substream
, &status
);
456 snd_iprintf(buffer
, "error %d\n", err
);
459 snd_iprintf(buffer
, "state: %s\n", snd_pcm_state_name(status
.state
));
460 snd_iprintf(buffer
, "owner_pid : %d\n", pid_vnr(substream
->pid
));
461 snd_iprintf(buffer
, "trigger_time: %ld.%09ld\n",
462 status
.trigger_tstamp
.tv_sec
, status
.trigger_tstamp
.tv_nsec
);
463 snd_iprintf(buffer
, "tstamp : %ld.%09ld\n",
464 status
.tstamp
.tv_sec
, status
.tstamp
.tv_nsec
);
465 snd_iprintf(buffer
, "delay : %ld\n", status
.delay
);
466 snd_iprintf(buffer
, "avail : %ld\n", status
.avail
);
467 snd_iprintf(buffer
, "avail_max : %ld\n", status
.avail_max
);
468 snd_iprintf(buffer
, "-----\n");
469 snd_iprintf(buffer
, "hw_ptr : %ld\n", runtime
->status
->hw_ptr
);
470 snd_iprintf(buffer
, "appl_ptr : %ld\n", runtime
->control
->appl_ptr
);
472 mutex_unlock(&substream
->pcm
->open_mutex
);
475 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
476 static void snd_pcm_xrun_debug_read(struct snd_info_entry
*entry
,
477 struct snd_info_buffer
*buffer
)
479 struct snd_pcm_str
*pstr
= entry
->private_data
;
480 snd_iprintf(buffer
, "%d\n", pstr
->xrun_debug
);
483 static void snd_pcm_xrun_debug_write(struct snd_info_entry
*entry
,
484 struct snd_info_buffer
*buffer
)
486 struct snd_pcm_str
*pstr
= entry
->private_data
;
488 if (!snd_info_get_line(buffer
, line
, sizeof(line
)))
489 pstr
->xrun_debug
= simple_strtoul(line
, NULL
, 10);
493 static int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
)
495 struct snd_pcm
*pcm
= pstr
->pcm
;
496 struct snd_info_entry
*entry
;
499 sprintf(name
, "pcm%i%c", pcm
->device
,
500 pstr
->stream
== SNDRV_PCM_STREAM_PLAYBACK
? 'p' : 'c');
501 if ((entry
= snd_info_create_card_entry(pcm
->card
, name
, pcm
->card
->proc_root
)) == NULL
)
503 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
504 if (snd_info_register(entry
) < 0) {
505 snd_info_free_entry(entry
);
508 pstr
->proc_root
= entry
;
510 if ((entry
= snd_info_create_card_entry(pcm
->card
, "info", pstr
->proc_root
)) != NULL
) {
511 snd_info_set_text_ops(entry
, pstr
, snd_pcm_stream_proc_info_read
);
512 if (snd_info_register(entry
) < 0) {
513 snd_info_free_entry(entry
);
517 pstr
->proc_info_entry
= entry
;
519 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
520 if ((entry
= snd_info_create_card_entry(pcm
->card
, "xrun_debug",
521 pstr
->proc_root
)) != NULL
) {
522 entry
->c
.text
.read
= snd_pcm_xrun_debug_read
;
523 entry
->c
.text
.write
= snd_pcm_xrun_debug_write
;
524 entry
->mode
|= S_IWUSR
;
525 entry
->private_data
= pstr
;
526 if (snd_info_register(entry
) < 0) {
527 snd_info_free_entry(entry
);
531 pstr
->proc_xrun_debug_entry
= entry
;
536 static int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
)
538 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
539 snd_info_free_entry(pstr
->proc_xrun_debug_entry
);
540 pstr
->proc_xrun_debug_entry
= NULL
;
542 snd_info_free_entry(pstr
->proc_info_entry
);
543 pstr
->proc_info_entry
= NULL
;
544 snd_info_free_entry(pstr
->proc_root
);
545 pstr
->proc_root
= NULL
;
549 static int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
)
551 struct snd_info_entry
*entry
;
552 struct snd_card
*card
;
555 card
= substream
->pcm
->card
;
557 sprintf(name
, "sub%i", substream
->number
);
558 if ((entry
= snd_info_create_card_entry(card
, name
, substream
->pstr
->proc_root
)) == NULL
)
560 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
561 if (snd_info_register(entry
) < 0) {
562 snd_info_free_entry(entry
);
565 substream
->proc_root
= entry
;
567 if ((entry
= snd_info_create_card_entry(card
, "info", substream
->proc_root
)) != NULL
) {
568 snd_info_set_text_ops(entry
, substream
,
569 snd_pcm_substream_proc_info_read
);
570 if (snd_info_register(entry
) < 0) {
571 snd_info_free_entry(entry
);
575 substream
->proc_info_entry
= entry
;
577 if ((entry
= snd_info_create_card_entry(card
, "hw_params", substream
->proc_root
)) != NULL
) {
578 snd_info_set_text_ops(entry
, substream
,
579 snd_pcm_substream_proc_hw_params_read
);
580 if (snd_info_register(entry
) < 0) {
581 snd_info_free_entry(entry
);
585 substream
->proc_hw_params_entry
= entry
;
587 if ((entry
= snd_info_create_card_entry(card
, "sw_params", substream
->proc_root
)) != NULL
) {
588 snd_info_set_text_ops(entry
, substream
,
589 snd_pcm_substream_proc_sw_params_read
);
590 if (snd_info_register(entry
) < 0) {
591 snd_info_free_entry(entry
);
595 substream
->proc_sw_params_entry
= entry
;
597 if ((entry
= snd_info_create_card_entry(card
, "status", substream
->proc_root
)) != NULL
) {
598 snd_info_set_text_ops(entry
, substream
,
599 snd_pcm_substream_proc_status_read
);
600 if (snd_info_register(entry
) < 0) {
601 snd_info_free_entry(entry
);
605 substream
->proc_status_entry
= entry
;
610 static int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
)
612 snd_info_free_entry(substream
->proc_info_entry
);
613 substream
->proc_info_entry
= NULL
;
614 snd_info_free_entry(substream
->proc_hw_params_entry
);
615 substream
->proc_hw_params_entry
= NULL
;
616 snd_info_free_entry(substream
->proc_sw_params_entry
);
617 substream
->proc_sw_params_entry
= NULL
;
618 snd_info_free_entry(substream
->proc_status_entry
);
619 substream
->proc_status_entry
= NULL
;
620 snd_info_free_entry(substream
->proc_root
);
621 substream
->proc_root
= NULL
;
624 #else /* !CONFIG_SND_VERBOSE_PROCFS */
625 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
) { return 0; }
626 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
) { return 0; }
627 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
) { return 0; }
628 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
) { return 0; }
629 #endif /* CONFIG_SND_VERBOSE_PROCFS */
632 * snd_pcm_new_stream - create a new PCM stream
633 * @pcm: the pcm instance
634 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
635 * @substream_count: the number of substreams
637 * Creates a new stream for the pcm.
638 * The corresponding stream on the pcm must have been empty before
639 * calling this, i.e. zero must be given to the argument of
642 * Return: Zero if successful, or a negative error code on failure.
644 int snd_pcm_new_stream(struct snd_pcm
*pcm
, int stream
, int substream_count
)
647 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
648 struct snd_pcm_substream
*substream
, *prev
;
650 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
651 mutex_init(&pstr
->oss
.setup_mutex
);
653 pstr
->stream
= stream
;
655 pstr
->substream_count
= substream_count
;
656 if (substream_count
> 0 && !pcm
->internal
) {
657 err
= snd_pcm_stream_proc_init(pstr
);
659 snd_printk(KERN_ERR
"Error in snd_pcm_stream_proc_init\n");
664 for (idx
= 0, prev
= NULL
; idx
< substream_count
; idx
++) {
665 substream
= kzalloc(sizeof(*substream
), GFP_KERNEL
);
666 if (substream
== NULL
) {
667 snd_printk(KERN_ERR
"Cannot allocate PCM substream\n");
670 substream
->pcm
= pcm
;
671 substream
->pstr
= pstr
;
672 substream
->number
= idx
;
673 substream
->stream
= stream
;
674 sprintf(substream
->name
, "subdevice #%i", idx
);
675 substream
->buffer_bytes_max
= UINT_MAX
;
677 pstr
->substream
= substream
;
679 prev
->next
= substream
;
681 if (!pcm
->internal
) {
682 err
= snd_pcm_substream_proc_init(substream
);
684 snd_printk(KERN_ERR
"Error in snd_pcm_stream_proc_init\n");
686 pstr
->substream
= NULL
;
693 substream
->group
= &substream
->self_group
;
694 spin_lock_init(&substream
->self_group
.lock
);
695 INIT_LIST_HEAD(&substream
->self_group
.substreams
);
696 list_add_tail(&substream
->link_list
, &substream
->self_group
.substreams
);
697 atomic_set(&substream
->mmap_count
, 0);
703 EXPORT_SYMBOL(snd_pcm_new_stream
);
705 static int _snd_pcm_new(struct snd_card
*card
, const char *id
, int device
,
706 int playback_count
, int capture_count
, bool internal
,
707 struct snd_pcm
**rpcm
)
711 static struct snd_device_ops ops
= {
712 .dev_free
= snd_pcm_dev_free
,
713 .dev_register
= snd_pcm_dev_register
,
714 .dev_disconnect
= snd_pcm_dev_disconnect
,
717 if (snd_BUG_ON(!card
))
721 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
723 snd_printk(KERN_ERR
"Cannot allocate PCM\n");
727 pcm
->device
= device
;
728 pcm
->internal
= internal
;
730 strlcpy(pcm
->id
, id
, sizeof(pcm
->id
));
731 if ((err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, playback_count
)) < 0) {
735 if ((err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_CAPTURE
, capture_count
)) < 0) {
739 mutex_init(&pcm
->open_mutex
);
740 init_waitqueue_head(&pcm
->open_wait
);
741 if ((err
= snd_device_new(card
, SNDRV_DEV_PCM
, pcm
, &ops
)) < 0) {
751 * snd_pcm_new - create a new PCM instance
752 * @card: the card instance
754 * @device: the device index (zero based)
755 * @playback_count: the number of substreams for playback
756 * @capture_count: the number of substreams for capture
757 * @rpcm: the pointer to store the new pcm instance
759 * Creates a new PCM instance.
761 * The pcm operators have to be set afterwards to the new instance
762 * via snd_pcm_set_ops().
764 * Return: Zero if successful, or a negative error code on failure.
766 int snd_pcm_new(struct snd_card
*card
, const char *id
, int device
,
767 int playback_count
, int capture_count
, struct snd_pcm
**rpcm
)
769 return _snd_pcm_new(card
, id
, device
, playback_count
, capture_count
,
772 EXPORT_SYMBOL(snd_pcm_new
);
775 * snd_pcm_new_internal - create a new internal PCM instance
776 * @card: the card instance
778 * @device: the device index (zero based - shared with normal PCMs)
779 * @playback_count: the number of substreams for playback
780 * @capture_count: the number of substreams for capture
781 * @rpcm: the pointer to store the new pcm instance
783 * Creates a new internal PCM instance with no userspace device or procfs
784 * entries. This is used by ASoC Back End PCMs in order to create a PCM that
785 * will only be used internally by kernel drivers. i.e. it cannot be opened
786 * by userspace. It provides existing ASoC components drivers with a substream
787 * and access to any private data.
789 * The pcm operators have to be set afterwards to the new instance
790 * via snd_pcm_set_ops().
792 * Return: Zero if successful, or a negative error code on failure.
794 int snd_pcm_new_internal(struct snd_card
*card
, const char *id
, int device
,
795 int playback_count
, int capture_count
,
796 struct snd_pcm
**rpcm
)
798 return _snd_pcm_new(card
, id
, device
, playback_count
, capture_count
,
801 EXPORT_SYMBOL(snd_pcm_new_internal
);
803 static void snd_pcm_free_stream(struct snd_pcm_str
* pstr
)
805 struct snd_pcm_substream
*substream
, *substream_next
;
806 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
807 struct snd_pcm_oss_setup
*setup
, *setupn
;
809 substream
= pstr
->substream
;
811 substream_next
= substream
->next
;
812 snd_pcm_timer_done(substream
);
813 snd_pcm_substream_proc_done(substream
);
815 substream
= substream_next
;
817 snd_pcm_stream_proc_done(pstr
);
818 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
819 for (setup
= pstr
->oss
.setup_list
; setup
; setup
= setupn
) {
820 setupn
= setup
->next
;
821 kfree(setup
->task_name
);
827 static int snd_pcm_free(struct snd_pcm
*pcm
)
829 struct snd_pcm_notify
*notify
;
833 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
) {
834 notify
->n_unregister(pcm
);
836 if (pcm
->private_free
)
837 pcm
->private_free(pcm
);
838 snd_pcm_lib_preallocate_free_for_all(pcm
);
839 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]);
840 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
]);
845 static int snd_pcm_dev_free(struct snd_device
*device
)
847 struct snd_pcm
*pcm
= device
->device_data
;
848 return snd_pcm_free(pcm
);
851 int snd_pcm_attach_substream(struct snd_pcm
*pcm
, int stream
,
853 struct snd_pcm_substream
**rsubstream
)
855 struct snd_pcm_str
* pstr
;
856 struct snd_pcm_substream
*substream
;
857 struct snd_pcm_runtime
*runtime
;
858 struct snd_ctl_file
*kctl
;
859 struct snd_card
*card
;
860 int prefer_subdevice
= -1;
863 if (snd_BUG_ON(!pcm
|| !rsubstream
))
866 pstr
= &pcm
->streams
[stream
];
867 if (pstr
->substream
== NULL
|| pstr
->substream_count
== 0)
871 read_lock(&card
->ctl_files_rwlock
);
872 list_for_each_entry(kctl
, &card
->ctl_files
, list
) {
873 if (kctl
->pid
== task_pid(current
)) {
874 prefer_subdevice
= kctl
->prefer_pcm_subdevice
;
875 if (prefer_subdevice
!= -1)
879 read_unlock(&card
->ctl_files_rwlock
);
882 case SNDRV_PCM_STREAM_PLAYBACK
:
883 if (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
) {
884 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
; substream
; substream
= substream
->next
) {
885 if (SUBSTREAM_BUSY(substream
))
890 case SNDRV_PCM_STREAM_CAPTURE
:
891 if (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
) {
892 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
; substream
; substream
= substream
->next
) {
893 if (SUBSTREAM_BUSY(substream
))
902 if (file
->f_flags
& O_APPEND
) {
903 if (prefer_subdevice
< 0) {
904 if (pstr
->substream_count
> 1)
905 return -EINVAL
; /* must be unique */
906 substream
= pstr
->substream
;
908 for (substream
= pstr
->substream
; substream
;
909 substream
= substream
->next
)
910 if (substream
->number
== prefer_subdevice
)
915 if (! SUBSTREAM_BUSY(substream
))
917 substream
->ref_count
++;
918 *rsubstream
= substream
;
922 if (prefer_subdevice
>= 0) {
923 for (substream
= pstr
->substream
; substream
; substream
= substream
->next
)
924 if (!SUBSTREAM_BUSY(substream
) && substream
->number
== prefer_subdevice
)
927 for (substream
= pstr
->substream
; substream
; substream
= substream
->next
)
928 if (!SUBSTREAM_BUSY(substream
))
931 if (substream
== NULL
)
934 runtime
= kzalloc(sizeof(*runtime
), GFP_KERNEL
);
938 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
));
939 runtime
->status
= snd_malloc_pages(size
, GFP_KERNEL
);
940 if (runtime
->status
== NULL
) {
944 memset((void*)runtime
->status
, 0, size
);
946 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
));
947 runtime
->control
= snd_malloc_pages(size
, GFP_KERNEL
);
948 if (runtime
->control
== NULL
) {
949 snd_free_pages((void*)runtime
->status
,
950 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
954 memset((void*)runtime
->control
, 0, size
);
956 init_waitqueue_head(&runtime
->sleep
);
957 init_waitqueue_head(&runtime
->tsleep
);
959 runtime
->status
->state
= SNDRV_PCM_STATE_OPEN
;
961 substream
->runtime
= runtime
;
962 substream
->private_data
= pcm
->private_data
;
963 substream
->ref_count
= 1;
964 substream
->f_flags
= file
->f_flags
;
965 substream
->pid
= get_pid(task_pid(current
));
966 pstr
->substream_opened
++;
967 *rsubstream
= substream
;
971 void snd_pcm_detach_substream(struct snd_pcm_substream
*substream
)
973 struct snd_pcm_runtime
*runtime
;
975 if (PCM_RUNTIME_CHECK(substream
))
977 runtime
= substream
->runtime
;
978 if (runtime
->private_free
!= NULL
)
979 runtime
->private_free(runtime
);
980 snd_free_pages((void*)runtime
->status
,
981 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
982 snd_free_pages((void*)runtime
->control
,
983 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
)));
984 kfree(runtime
->hw_constraints
.rules
);
985 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
986 kfree(runtime
->hwptr_log
);
989 substream
->runtime
= NULL
;
990 put_pid(substream
->pid
);
991 substream
->pid
= NULL
;
992 substream
->pstr
->substream_opened
--;
995 static ssize_t
show_pcm_class(struct device
*dev
,
996 struct device_attribute
*attr
, char *buf
)
1000 static const char *strs
[SNDRV_PCM_CLASS_LAST
+ 1] = {
1001 [SNDRV_PCM_CLASS_GENERIC
] = "generic",
1002 [SNDRV_PCM_CLASS_MULTI
] = "multi",
1003 [SNDRV_PCM_CLASS_MODEM
] = "modem",
1004 [SNDRV_PCM_CLASS_DIGITIZER
] = "digitizer",
1007 if (! (pcm
= dev_get_drvdata(dev
)) ||
1008 pcm
->dev_class
> SNDRV_PCM_CLASS_LAST
)
1011 str
= strs
[pcm
->dev_class
];
1012 return snprintf(buf
, PAGE_SIZE
, "%s\n", str
);
1015 static struct device_attribute pcm_attrs
=
1016 __ATTR(pcm_class
, S_IRUGO
, show_pcm_class
, NULL
);
1018 static int snd_pcm_dev_register(struct snd_device
*device
)
1021 struct snd_pcm_substream
*substream
;
1022 struct snd_pcm_notify
*notify
;
1024 struct snd_pcm
*pcm
;
1027 if (snd_BUG_ON(!device
|| !device
->device_data
))
1029 pcm
= device
->device_data
;
1030 mutex_lock(®ister_mutex
);
1031 err
= snd_pcm_add(pcm
);
1033 mutex_unlock(®ister_mutex
);
1036 for (cidx
= 0; cidx
< 2; cidx
++) {
1038 if (pcm
->streams
[cidx
].substream
== NULL
|| pcm
->internal
)
1041 case SNDRV_PCM_STREAM_PLAYBACK
:
1042 sprintf(str
, "pcmC%iD%ip", pcm
->card
->number
, pcm
->device
);
1043 devtype
= SNDRV_DEVICE_TYPE_PCM_PLAYBACK
;
1045 case SNDRV_PCM_STREAM_CAPTURE
:
1046 sprintf(str
, "pcmC%iD%ic", pcm
->card
->number
, pcm
->device
);
1047 devtype
= SNDRV_DEVICE_TYPE_PCM_CAPTURE
;
1050 /* device pointer to use, pcm->dev takes precedence if
1051 * it is assigned, otherwise fall back to card's device
1055 dev
= snd_card_get_device_link(pcm
->card
);
1057 err
= snd_register_device_for_dev(devtype
, pcm
->card
,
1059 &snd_pcm_f_ops
[cidx
],
1062 list_del(&pcm
->list
);
1063 mutex_unlock(®ister_mutex
);
1066 snd_add_device_sysfs_file(devtype
, pcm
->card
, pcm
->device
,
1068 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
)
1069 snd_pcm_timer_init(substream
);
1072 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
)
1073 notify
->n_register(pcm
);
1075 mutex_unlock(®ister_mutex
);
1079 static int snd_pcm_dev_disconnect(struct snd_device
*device
)
1081 struct snd_pcm
*pcm
= device
->device_data
;
1082 struct snd_pcm_notify
*notify
;
1083 struct snd_pcm_substream
*substream
;
1086 mutex_lock(®ister_mutex
);
1087 if (list_empty(&pcm
->list
))
1090 mutex_lock(&pcm
->open_mutex
);
1091 wake_up(&pcm
->open_wait
);
1092 list_del_init(&pcm
->list
);
1093 for (cidx
= 0; cidx
< 2; cidx
++)
1094 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
) {
1095 snd_pcm_stream_lock_irq(substream
);
1096 if (substream
->runtime
) {
1097 substream
->runtime
->status
->state
= SNDRV_PCM_STATE_DISCONNECTED
;
1098 wake_up(&substream
->runtime
->sleep
);
1099 wake_up(&substream
->runtime
->tsleep
);
1101 snd_pcm_stream_unlock_irq(substream
);
1103 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
) {
1104 notify
->n_disconnect(pcm
);
1106 for (cidx
= 0; cidx
< 2; cidx
++) {
1109 case SNDRV_PCM_STREAM_PLAYBACK
:
1110 devtype
= SNDRV_DEVICE_TYPE_PCM_PLAYBACK
;
1112 case SNDRV_PCM_STREAM_CAPTURE
:
1113 devtype
= SNDRV_DEVICE_TYPE_PCM_CAPTURE
;
1116 snd_unregister_device(devtype
, pcm
->card
, pcm
->device
);
1117 if (pcm
->streams
[cidx
].chmap_kctl
) {
1118 snd_ctl_remove(pcm
->card
, pcm
->streams
[cidx
].chmap_kctl
);
1119 pcm
->streams
[cidx
].chmap_kctl
= NULL
;
1122 mutex_unlock(&pcm
->open_mutex
);
1124 mutex_unlock(®ister_mutex
);
1128 int snd_pcm_notify(struct snd_pcm_notify
*notify
, int nfree
)
1130 struct snd_pcm
*pcm
;
1132 if (snd_BUG_ON(!notify
||
1133 !notify
->n_register
||
1134 !notify
->n_unregister
||
1135 !notify
->n_disconnect
))
1137 mutex_lock(®ister_mutex
);
1139 list_del(¬ify
->list
);
1140 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1141 notify
->n_unregister(pcm
);
1143 list_add_tail(¬ify
->list
, &snd_pcm_notify_list
);
1144 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1145 notify
->n_register(pcm
);
1147 mutex_unlock(®ister_mutex
);
1151 EXPORT_SYMBOL(snd_pcm_notify
);
1153 #ifdef CONFIG_PROC_FS
1158 static void snd_pcm_proc_read(struct snd_info_entry
*entry
,
1159 struct snd_info_buffer
*buffer
)
1161 struct snd_pcm
*pcm
;
1163 mutex_lock(®ister_mutex
);
1164 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
1165 snd_iprintf(buffer
, "%02i-%02i: %s : %s",
1166 pcm
->card
->number
, pcm
->device
, pcm
->id
, pcm
->name
);
1167 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
)
1168 snd_iprintf(buffer
, " : playback %i",
1169 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream_count
);
1170 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
)
1171 snd_iprintf(buffer
, " : capture %i",
1172 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
);
1173 snd_iprintf(buffer
, "\n");
1175 mutex_unlock(®ister_mutex
);
1178 static struct snd_info_entry
*snd_pcm_proc_entry
;
1180 static void snd_pcm_proc_init(void)
1182 struct snd_info_entry
*entry
;
1184 if ((entry
= snd_info_create_module_entry(THIS_MODULE
, "pcm", NULL
)) != NULL
) {
1185 snd_info_set_text_ops(entry
, NULL
, snd_pcm_proc_read
);
1186 if (snd_info_register(entry
) < 0) {
1187 snd_info_free_entry(entry
);
1191 snd_pcm_proc_entry
= entry
;
1194 static void snd_pcm_proc_done(void)
1196 snd_info_free_entry(snd_pcm_proc_entry
);
1199 #else /* !CONFIG_PROC_FS */
1200 #define snd_pcm_proc_init()
1201 #define snd_pcm_proc_done()
1202 #endif /* CONFIG_PROC_FS */
1209 static int __init
alsa_pcm_init(void)
1211 snd_ctl_register_ioctl(snd_pcm_control_ioctl
);
1212 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl
);
1213 snd_pcm_proc_init();
1217 static void __exit
alsa_pcm_exit(void)
1219 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl
);
1220 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl
);
1221 snd_pcm_proc_done();
1224 module_init(alsa_pcm_init
)
1225 module_exit(alsa_pcm_exit
)