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 <sound/driver.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/time.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include <sound/minors.h>
29 #include <sound/pcm.h>
30 #include <sound/control.h>
31 #include <sound/info.h>
33 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Abramo Bagnara <abramo@alsa-project.org>");
34 MODULE_DESCRIPTION("Midlevel PCM code for ALSA.");
35 MODULE_LICENSE("GPL");
37 static LIST_HEAD(snd_pcm_devices
);
38 static LIST_HEAD(snd_pcm_notify_list
);
39 static DEFINE_MUTEX(register_mutex
);
41 static int snd_pcm_free(struct snd_pcm
*pcm
);
42 static int snd_pcm_dev_free(struct snd_device
*device
);
43 static int snd_pcm_dev_register(struct snd_device
*device
);
44 static int snd_pcm_dev_disconnect(struct snd_device
*device
);
46 static struct snd_pcm
*snd_pcm_search(struct snd_card
*card
, int device
)
50 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
51 if (pcm
->card
== card
&& pcm
->device
== device
)
57 static int snd_pcm_control_ioctl(struct snd_card
*card
,
58 struct snd_ctl_file
*control
,
59 unsigned int cmd
, unsigned long arg
)
62 case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE
:
66 if (get_user(device
, (int __user
*)arg
))
68 mutex_lock(®ister_mutex
);
69 device
= device
< 0 ? 0 : device
+ 1;
70 while (device
< SNDRV_PCM_DEVICES
) {
71 if (snd_pcm_search(card
, device
))
75 if (device
== SNDRV_PCM_DEVICES
)
77 mutex_unlock(®ister_mutex
);
78 if (put_user(device
, (int __user
*)arg
))
82 case SNDRV_CTL_IOCTL_PCM_INFO
:
84 struct snd_pcm_info __user
*info
;
85 unsigned int device
, subdevice
;
88 struct snd_pcm_str
*pstr
;
89 struct snd_pcm_substream
*substream
;
92 info
= (struct snd_pcm_info __user
*)arg
;
93 if (get_user(device
, &info
->device
))
95 if (get_user(stream
, &info
->stream
))
97 if (stream
< 0 || stream
> 1)
99 if (get_user(subdevice
, &info
->subdevice
))
101 mutex_lock(®ister_mutex
);
102 pcm
= snd_pcm_search(card
, device
);
107 pstr
= &pcm
->streams
[stream
];
108 if (pstr
->substream_count
== 0) {
112 if (subdevice
>= pstr
->substream_count
) {
116 for (substream
= pstr
->substream
; substream
;
117 substream
= substream
->next
)
118 if (substream
->number
== (int)subdevice
)
120 if (substream
== NULL
) {
124 err
= snd_pcm_info_user(substream
, info
);
126 mutex_unlock(®ister_mutex
);
129 case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE
:
133 if (get_user(val
, (int __user
*)arg
))
135 control
->prefer_pcm_subdevice
= val
;
142 #ifdef CONFIG_SND_VERBOSE_PROCFS
144 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
145 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
146 #define READY(v) [SNDRV_PCM_READY_##v] = #v
147 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
148 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
149 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
150 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
151 #define START(v) [SNDRV_PCM_START_##v] = #v
152 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
153 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
155 static char *snd_pcm_format_names
[] = {
174 FORMAT(IEC958_SUBFRAME_LE
),
175 FORMAT(IEC958_SUBFRAME_BE
),
196 static const char *snd_pcm_format_name(snd_pcm_format_t format
)
198 return snd_pcm_format_names
[format
];
201 static char *snd_pcm_stream_names
[] = {
206 static char *snd_pcm_state_names
[] = {
217 static char *snd_pcm_access_names
[] = {
218 ACCESS(MMAP_INTERLEAVED
),
219 ACCESS(MMAP_NONINTERLEAVED
),
220 ACCESS(MMAP_COMPLEX
),
221 ACCESS(RW_INTERLEAVED
),
222 ACCESS(RW_NONINTERLEAVED
),
225 static char *snd_pcm_subformat_names
[] = {
229 static char *snd_pcm_tstamp_mode_names
[] = {
234 static const char *snd_pcm_stream_name(int stream
)
236 snd_assert(stream
<= SNDRV_PCM_STREAM_LAST
, return NULL
);
237 return snd_pcm_stream_names
[stream
];
240 static const char *snd_pcm_access_name(snd_pcm_access_t access
)
242 return snd_pcm_access_names
[access
];
245 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat
)
247 return snd_pcm_subformat_names
[subformat
];
250 static const char *snd_pcm_tstamp_mode_name(int mode
)
252 snd_assert(mode
<= SNDRV_PCM_TSTAMP_LAST
, return NULL
);
253 return snd_pcm_tstamp_mode_names
[mode
];
256 static const char *snd_pcm_state_name(snd_pcm_state_t state
)
258 return snd_pcm_state_names
[state
];
261 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
262 #include <linux/soundcard.h>
264 static const char *snd_pcm_oss_format_name(int format
)
293 static void snd_pcm_proc_info_read(struct snd_pcm_substream
*substream
,
294 struct snd_info_buffer
*buffer
)
296 struct snd_pcm_info
*info
;
302 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
304 printk(KERN_DEBUG
"snd_pcm_proc_info_read: cannot malloc\n");
308 err
= snd_pcm_info(substream
, info
);
310 snd_iprintf(buffer
, "error %d\n", err
);
314 snd_iprintf(buffer
, "card: %d\n", info
->card
);
315 snd_iprintf(buffer
, "device: %d\n", info
->device
);
316 snd_iprintf(buffer
, "subdevice: %d\n", info
->subdevice
);
317 snd_iprintf(buffer
, "stream: %s\n", snd_pcm_stream_name(info
->stream
));
318 snd_iprintf(buffer
, "id: %s\n", info
->id
);
319 snd_iprintf(buffer
, "name: %s\n", info
->name
);
320 snd_iprintf(buffer
, "subname: %s\n", info
->subname
);
321 snd_iprintf(buffer
, "class: %d\n", info
->dev_class
);
322 snd_iprintf(buffer
, "subclass: %d\n", info
->dev_subclass
);
323 snd_iprintf(buffer
, "subdevices_count: %d\n", info
->subdevices_count
);
324 snd_iprintf(buffer
, "subdevices_avail: %d\n", info
->subdevices_avail
);
328 static void snd_pcm_stream_proc_info_read(struct snd_info_entry
*entry
,
329 struct snd_info_buffer
*buffer
)
331 snd_pcm_proc_info_read(((struct snd_pcm_str
*)entry
->private_data
)->substream
,
335 static void snd_pcm_substream_proc_info_read(struct snd_info_entry
*entry
,
336 struct snd_info_buffer
*buffer
)
338 snd_pcm_proc_info_read((struct snd_pcm_substream
*)entry
->private_data
,
342 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry
*entry
,
343 struct snd_info_buffer
*buffer
)
345 struct snd_pcm_substream
*substream
= entry
->private_data
;
346 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
348 snd_iprintf(buffer
, "closed\n");
351 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
352 snd_iprintf(buffer
, "no setup\n");
355 snd_iprintf(buffer
, "access: %s\n", snd_pcm_access_name(runtime
->access
));
356 snd_iprintf(buffer
, "format: %s\n", snd_pcm_format_name(runtime
->format
));
357 snd_iprintf(buffer
, "subformat: %s\n", snd_pcm_subformat_name(runtime
->subformat
));
358 snd_iprintf(buffer
, "channels: %u\n", runtime
->channels
);
359 snd_iprintf(buffer
, "rate: %u (%u/%u)\n", runtime
->rate
, runtime
->rate_num
, runtime
->rate_den
);
360 snd_iprintf(buffer
, "period_size: %lu\n", runtime
->period_size
);
361 snd_iprintf(buffer
, "buffer_size: %lu\n", runtime
->buffer_size
);
362 snd_iprintf(buffer
, "tick_time: %u\n", runtime
->tick_time
);
363 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
364 if (substream
->oss
.oss
) {
365 snd_iprintf(buffer
, "OSS format: %s\n", snd_pcm_oss_format_name(runtime
->oss
.format
));
366 snd_iprintf(buffer
, "OSS channels: %u\n", runtime
->oss
.channels
);
367 snd_iprintf(buffer
, "OSS rate: %u\n", runtime
->oss
.rate
);
368 snd_iprintf(buffer
, "OSS period bytes: %lu\n", (unsigned long)runtime
->oss
.period_bytes
);
369 snd_iprintf(buffer
, "OSS periods: %u\n", runtime
->oss
.periods
);
370 snd_iprintf(buffer
, "OSS period frames: %lu\n", (unsigned long)runtime
->oss
.period_frames
);
375 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry
*entry
,
376 struct snd_info_buffer
*buffer
)
378 struct snd_pcm_substream
*substream
= entry
->private_data
;
379 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
381 snd_iprintf(buffer
, "closed\n");
384 if (runtime
->status
->state
== SNDRV_PCM_STATE_OPEN
) {
385 snd_iprintf(buffer
, "no setup\n");
388 snd_iprintf(buffer
, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime
->tstamp_mode
));
389 snd_iprintf(buffer
, "period_step: %u\n", runtime
->period_step
);
390 snd_iprintf(buffer
, "sleep_min: %u\n", runtime
->sleep_min
);
391 snd_iprintf(buffer
, "avail_min: %lu\n", runtime
->control
->avail_min
);
392 snd_iprintf(buffer
, "xfer_align: %lu\n", runtime
->xfer_align
);
393 snd_iprintf(buffer
, "start_threshold: %lu\n", runtime
->start_threshold
);
394 snd_iprintf(buffer
, "stop_threshold: %lu\n", runtime
->stop_threshold
);
395 snd_iprintf(buffer
, "silence_threshold: %lu\n", runtime
->silence_threshold
);
396 snd_iprintf(buffer
, "silence_size: %lu\n", runtime
->silence_size
);
397 snd_iprintf(buffer
, "boundary: %lu\n", runtime
->boundary
);
400 static void snd_pcm_substream_proc_status_read(struct snd_info_entry
*entry
,
401 struct snd_info_buffer
*buffer
)
403 struct snd_pcm_substream
*substream
= entry
->private_data
;
404 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
405 struct snd_pcm_status status
;
408 snd_iprintf(buffer
, "closed\n");
411 memset(&status
, 0, sizeof(status
));
412 err
= snd_pcm_status(substream
, &status
);
414 snd_iprintf(buffer
, "error %d\n", err
);
417 snd_iprintf(buffer
, "state: %s\n", snd_pcm_state_name(status
.state
));
418 snd_iprintf(buffer
, "trigger_time: %ld.%09ld\n",
419 status
.trigger_tstamp
.tv_sec
, status
.trigger_tstamp
.tv_nsec
);
420 snd_iprintf(buffer
, "tstamp : %ld.%09ld\n",
421 status
.tstamp
.tv_sec
, status
.tstamp
.tv_nsec
);
422 snd_iprintf(buffer
, "delay : %ld\n", status
.delay
);
423 snd_iprintf(buffer
, "avail : %ld\n", status
.avail
);
424 snd_iprintf(buffer
, "avail_max : %ld\n", status
.avail_max
);
425 snd_iprintf(buffer
, "-----\n");
426 snd_iprintf(buffer
, "hw_ptr : %ld\n", runtime
->status
->hw_ptr
);
427 snd_iprintf(buffer
, "appl_ptr : %ld\n", runtime
->control
->appl_ptr
);
430 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
431 static void snd_pcm_xrun_debug_read(struct snd_info_entry
*entry
,
432 struct snd_info_buffer
*buffer
)
434 struct snd_pcm_str
*pstr
= entry
->private_data
;
435 snd_iprintf(buffer
, "%d\n", pstr
->xrun_debug
);
438 static void snd_pcm_xrun_debug_write(struct snd_info_entry
*entry
,
439 struct snd_info_buffer
*buffer
)
441 struct snd_pcm_str
*pstr
= entry
->private_data
;
443 if (!snd_info_get_line(buffer
, line
, sizeof(line
)))
444 pstr
->xrun_debug
= simple_strtoul(line
, NULL
, 10);
448 static int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
)
450 struct snd_pcm
*pcm
= pstr
->pcm
;
451 struct snd_info_entry
*entry
;
454 sprintf(name
, "pcm%i%c", pcm
->device
,
455 pstr
->stream
== SNDRV_PCM_STREAM_PLAYBACK
? 'p' : 'c');
456 if ((entry
= snd_info_create_card_entry(pcm
->card
, name
, pcm
->card
->proc_root
)) == NULL
)
458 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
459 if (snd_info_register(entry
) < 0) {
460 snd_info_free_entry(entry
);
463 pstr
->proc_root
= entry
;
465 if ((entry
= snd_info_create_card_entry(pcm
->card
, "info", pstr
->proc_root
)) != NULL
) {
466 snd_info_set_text_ops(entry
, pstr
, snd_pcm_stream_proc_info_read
);
467 if (snd_info_register(entry
) < 0) {
468 snd_info_free_entry(entry
);
472 pstr
->proc_info_entry
= entry
;
474 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
475 if ((entry
= snd_info_create_card_entry(pcm
->card
, "xrun_debug",
476 pstr
->proc_root
)) != NULL
) {
477 entry
->c
.text
.read
= snd_pcm_xrun_debug_read
;
478 entry
->c
.text
.write
= snd_pcm_xrun_debug_write
;
479 entry
->mode
|= S_IWUSR
;
480 entry
->private_data
= pstr
;
481 if (snd_info_register(entry
) < 0) {
482 snd_info_free_entry(entry
);
486 pstr
->proc_xrun_debug_entry
= entry
;
491 static int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
)
493 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
494 snd_info_free_entry(pstr
->proc_xrun_debug_entry
);
495 pstr
->proc_xrun_debug_entry
= NULL
;
497 snd_info_free_entry(pstr
->proc_info_entry
);
498 pstr
->proc_info_entry
= NULL
;
499 snd_info_free_entry(pstr
->proc_root
);
500 pstr
->proc_root
= NULL
;
504 static int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
)
506 struct snd_info_entry
*entry
;
507 struct snd_card
*card
;
510 card
= substream
->pcm
->card
;
512 sprintf(name
, "sub%i", substream
->number
);
513 if ((entry
= snd_info_create_card_entry(card
, name
, substream
->pstr
->proc_root
)) == NULL
)
515 entry
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
516 if (snd_info_register(entry
) < 0) {
517 snd_info_free_entry(entry
);
520 substream
->proc_root
= entry
;
522 if ((entry
= snd_info_create_card_entry(card
, "info", substream
->proc_root
)) != NULL
) {
523 snd_info_set_text_ops(entry
, substream
,
524 snd_pcm_substream_proc_info_read
);
525 if (snd_info_register(entry
) < 0) {
526 snd_info_free_entry(entry
);
530 substream
->proc_info_entry
= entry
;
532 if ((entry
= snd_info_create_card_entry(card
, "hw_params", substream
->proc_root
)) != NULL
) {
533 snd_info_set_text_ops(entry
, substream
,
534 snd_pcm_substream_proc_hw_params_read
);
535 if (snd_info_register(entry
) < 0) {
536 snd_info_free_entry(entry
);
540 substream
->proc_hw_params_entry
= entry
;
542 if ((entry
= snd_info_create_card_entry(card
, "sw_params", substream
->proc_root
)) != NULL
) {
543 snd_info_set_text_ops(entry
, substream
,
544 snd_pcm_substream_proc_sw_params_read
);
545 if (snd_info_register(entry
) < 0) {
546 snd_info_free_entry(entry
);
550 substream
->proc_sw_params_entry
= entry
;
552 if ((entry
= snd_info_create_card_entry(card
, "status", substream
->proc_root
)) != NULL
) {
553 snd_info_set_text_ops(entry
, substream
,
554 snd_pcm_substream_proc_status_read
);
555 if (snd_info_register(entry
) < 0) {
556 snd_info_free_entry(entry
);
560 substream
->proc_status_entry
= entry
;
565 static int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
)
567 snd_info_free_entry(substream
->proc_info_entry
);
568 substream
->proc_info_entry
= NULL
;
569 snd_info_free_entry(substream
->proc_hw_params_entry
);
570 substream
->proc_hw_params_entry
= NULL
;
571 snd_info_free_entry(substream
->proc_sw_params_entry
);
572 substream
->proc_sw_params_entry
= NULL
;
573 snd_info_free_entry(substream
->proc_status_entry
);
574 substream
->proc_status_entry
= NULL
;
575 snd_info_free_entry(substream
->proc_root
);
576 substream
->proc_root
= NULL
;
579 #else /* !CONFIG_SND_VERBOSE_PROCFS */
580 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str
*pstr
) { return 0; }
581 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str
*pstr
) { return 0; }
582 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream
*substream
) { return 0; }
583 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream
*substream
) { return 0; }
584 #endif /* CONFIG_SND_VERBOSE_PROCFS */
587 * snd_pcm_new_stream - create a new PCM stream
588 * @pcm: the pcm instance
589 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
590 * @substream_count: the number of substreams
592 * Creates a new stream for the pcm.
593 * The corresponding stream on the pcm must have been empty before
594 * calling this, i.e. zero must be given to the argument of
597 * Returns zero if successful, or a negative error code on failure.
599 int snd_pcm_new_stream(struct snd_pcm
*pcm
, int stream
, int substream_count
)
602 struct snd_pcm_str
*pstr
= &pcm
->streams
[stream
];
603 struct snd_pcm_substream
*substream
, *prev
;
605 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
606 mutex_init(&pstr
->oss
.setup_mutex
);
608 pstr
->stream
= stream
;
610 pstr
->substream_count
= substream_count
;
611 if (substream_count
> 0) {
612 err
= snd_pcm_stream_proc_init(pstr
);
614 snd_printk(KERN_ERR
"Error in snd_pcm_stream_proc_init\n");
619 for (idx
= 0, prev
= NULL
; idx
< substream_count
; idx
++) {
620 substream
= kzalloc(sizeof(*substream
), GFP_KERNEL
);
621 if (substream
== NULL
) {
622 snd_printk(KERN_ERR
"Cannot allocate PCM substream\n");
625 substream
->pcm
= pcm
;
626 substream
->pstr
= pstr
;
627 substream
->number
= idx
;
628 substream
->stream
= stream
;
629 sprintf(substream
->name
, "subdevice #%i", idx
);
630 snprintf(substream
->latency_id
, sizeof(substream
->latency_id
),
631 "ALSA-PCM%d-%d%c%d", pcm
->card
->number
, pcm
->device
,
632 (stream
? 'c' : 'p'), idx
);
633 substream
->buffer_bytes_max
= UINT_MAX
;
635 pstr
->substream
= substream
;
637 prev
->next
= substream
;
638 err
= snd_pcm_substream_proc_init(substream
);
640 snd_printk(KERN_ERR
"Error in snd_pcm_stream_proc_init\n");
642 pstr
->substream
= NULL
;
648 substream
->group
= &substream
->self_group
;
649 spin_lock_init(&substream
->self_group
.lock
);
650 INIT_LIST_HEAD(&substream
->self_group
.substreams
);
651 list_add_tail(&substream
->link_list
, &substream
->self_group
.substreams
);
652 spin_lock_init(&substream
->timer_lock
);
653 atomic_set(&substream
->mmap_count
, 0);
659 EXPORT_SYMBOL(snd_pcm_new_stream
);
662 * snd_pcm_new - create a new PCM instance
663 * @card: the card instance
665 * @device: the device index (zero based)
666 * @playback_count: the number of substreams for playback
667 * @capture_count: the number of substreams for capture
668 * @rpcm: the pointer to store the new pcm instance
670 * Creates a new PCM instance.
672 * The pcm operators have to be set afterwards to the new instance
673 * via snd_pcm_set_ops().
675 * Returns zero if successful, or a negative error code on failure.
677 int snd_pcm_new(struct snd_card
*card
, char *id
, int device
,
678 int playback_count
, int capture_count
,
679 struct snd_pcm
** rpcm
)
683 static struct snd_device_ops ops
= {
684 .dev_free
= snd_pcm_dev_free
,
685 .dev_register
= snd_pcm_dev_register
,
686 .dev_disconnect
= snd_pcm_dev_disconnect
,
689 snd_assert(rpcm
!= NULL
, return -EINVAL
);
691 snd_assert(card
!= NULL
, return -ENXIO
);
692 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
694 snd_printk(KERN_ERR
"Cannot allocate PCM\n");
698 pcm
->device
= device
;
700 strlcpy(pcm
->id
, id
, sizeof(pcm
->id
));
701 if ((err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, playback_count
)) < 0) {
705 if ((err
= snd_pcm_new_stream(pcm
, SNDRV_PCM_STREAM_CAPTURE
, capture_count
)) < 0) {
709 mutex_init(&pcm
->open_mutex
);
710 init_waitqueue_head(&pcm
->open_wait
);
711 if ((err
= snd_device_new(card
, SNDRV_DEV_PCM
, pcm
, &ops
)) < 0) {
719 EXPORT_SYMBOL(snd_pcm_new
);
721 static void snd_pcm_free_stream(struct snd_pcm_str
* pstr
)
723 struct snd_pcm_substream
*substream
, *substream_next
;
724 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
725 struct snd_pcm_oss_setup
*setup
, *setupn
;
727 substream
= pstr
->substream
;
729 substream_next
= substream
->next
;
730 snd_pcm_timer_done(substream
);
731 snd_pcm_substream_proc_done(substream
);
733 substream
= substream_next
;
735 snd_pcm_stream_proc_done(pstr
);
736 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
737 for (setup
= pstr
->oss
.setup_list
; setup
; setup
= setupn
) {
738 setupn
= setup
->next
;
739 kfree(setup
->task_name
);
745 static int snd_pcm_free(struct snd_pcm
*pcm
)
747 struct snd_pcm_notify
*notify
;
749 snd_assert(pcm
!= NULL
, return -ENXIO
);
750 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
) {
751 notify
->n_unregister(pcm
);
753 if (pcm
->private_free
)
754 pcm
->private_free(pcm
);
755 snd_pcm_lib_preallocate_free_for_all(pcm
);
756 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
]);
757 snd_pcm_free_stream(&pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
]);
762 static int snd_pcm_dev_free(struct snd_device
*device
)
764 struct snd_pcm
*pcm
= device
->device_data
;
765 return snd_pcm_free(pcm
);
768 static void snd_pcm_tick_timer_func(unsigned long data
)
770 struct snd_pcm_substream
*substream
= (struct snd_pcm_substream
*) data
;
771 snd_pcm_tick_elapsed(substream
);
774 int snd_pcm_attach_substream(struct snd_pcm
*pcm
, int stream
,
776 struct snd_pcm_substream
**rsubstream
)
778 struct snd_pcm_str
* pstr
;
779 struct snd_pcm_substream
*substream
;
780 struct snd_pcm_runtime
*runtime
;
781 struct snd_ctl_file
*kctl
;
782 struct snd_card
*card
;
783 int prefer_subdevice
= -1;
786 snd_assert(rsubstream
!= NULL
, return -EINVAL
);
788 snd_assert(pcm
!= NULL
, return -ENXIO
);
789 pstr
= &pcm
->streams
[stream
];
790 if (pstr
->substream
== NULL
|| pstr
->substream_count
== 0)
794 down_read(&card
->controls_rwsem
);
795 list_for_each_entry(kctl
, &card
->ctl_files
, list
) {
796 if (kctl
->pid
== current
->pid
) {
797 prefer_subdevice
= kctl
->prefer_pcm_subdevice
;
798 if (prefer_subdevice
!= -1)
802 up_read(&card
->controls_rwsem
);
805 case SNDRV_PCM_STREAM_PLAYBACK
:
806 if (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
) {
807 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
; substream
; substream
= substream
->next
) {
808 if (SUBSTREAM_BUSY(substream
))
813 case SNDRV_PCM_STREAM_CAPTURE
:
814 if (pcm
->info_flags
& SNDRV_PCM_INFO_HALF_DUPLEX
) {
815 for (substream
= pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
; substream
; substream
= substream
->next
) {
816 if (SUBSTREAM_BUSY(substream
))
825 if (file
->f_flags
& O_APPEND
) {
826 if (prefer_subdevice
< 0) {
827 if (pstr
->substream_count
> 1)
828 return -EINVAL
; /* must be unique */
829 substream
= pstr
->substream
;
831 for (substream
= pstr
->substream
; substream
;
832 substream
= substream
->next
)
833 if (substream
->number
== prefer_subdevice
)
838 if (! SUBSTREAM_BUSY(substream
))
840 substream
->ref_count
++;
841 *rsubstream
= substream
;
845 if (prefer_subdevice
>= 0) {
846 for (substream
= pstr
->substream
; substream
; substream
= substream
->next
)
847 if (!SUBSTREAM_BUSY(substream
) && substream
->number
== prefer_subdevice
)
850 for (substream
= pstr
->substream
; substream
; substream
= substream
->next
)
851 if (!SUBSTREAM_BUSY(substream
))
854 if (substream
== NULL
)
857 runtime
= kzalloc(sizeof(*runtime
), GFP_KERNEL
);
861 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
));
862 runtime
->status
= snd_malloc_pages(size
, GFP_KERNEL
);
863 if (runtime
->status
== NULL
) {
867 memset((void*)runtime
->status
, 0, size
);
869 size
= PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
));
870 runtime
->control
= snd_malloc_pages(size
, GFP_KERNEL
);
871 if (runtime
->control
== NULL
) {
872 snd_free_pages((void*)runtime
->status
,
873 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
877 memset((void*)runtime
->control
, 0, size
);
879 init_waitqueue_head(&runtime
->sleep
);
880 init_timer(&runtime
->tick_timer
);
881 runtime
->tick_timer
.function
= snd_pcm_tick_timer_func
;
882 runtime
->tick_timer
.data
= (unsigned long) substream
;
884 runtime
->status
->state
= SNDRV_PCM_STATE_OPEN
;
886 substream
->runtime
= runtime
;
887 substream
->private_data
= pcm
->private_data
;
888 substream
->ref_count
= 1;
889 substream
->f_flags
= file
->f_flags
;
890 pstr
->substream_opened
++;
891 *rsubstream
= substream
;
895 void snd_pcm_detach_substream(struct snd_pcm_substream
*substream
)
897 struct snd_pcm_runtime
*runtime
;
899 runtime
= substream
->runtime
;
900 snd_assert(runtime
!= NULL
, return);
901 if (runtime
->private_free
!= NULL
)
902 runtime
->private_free(runtime
);
903 snd_free_pages((void*)runtime
->status
,
904 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status
)));
905 snd_free_pages((void*)runtime
->control
,
906 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control
)));
907 kfree(runtime
->hw_constraints
.rules
);
909 substream
->runtime
= NULL
;
910 substream
->pstr
->substream_opened
--;
913 static ssize_t
show_pcm_class(struct device
*dev
,
914 struct device_attribute
*attr
, char *buf
)
918 static const char *strs
[SNDRV_PCM_CLASS_LAST
+ 1] = {
919 [SNDRV_PCM_CLASS_GENERIC
] = "generic",
920 [SNDRV_PCM_CLASS_MULTI
] = "multi",
921 [SNDRV_PCM_CLASS_MODEM
] = "modem",
922 [SNDRV_PCM_CLASS_DIGITIZER
] = "digitizer",
925 if (! (pcm
= dev_get_drvdata(dev
)) ||
926 pcm
->dev_class
> SNDRV_PCM_CLASS_LAST
)
929 str
= strs
[pcm
->dev_class
];
930 return snprintf(buf
, PAGE_SIZE
, "%s\n", str
);
933 static struct device_attribute pcm_attrs
=
934 __ATTR(pcm_class
, S_IRUGO
, show_pcm_class
, NULL
);
936 static int snd_pcm_dev_register(struct snd_device
*device
)
939 struct snd_pcm_substream
*substream
;
940 struct snd_pcm_notify
*notify
;
942 struct snd_pcm
*pcm
= device
->device_data
;
945 snd_assert(pcm
!= NULL
&& device
!= NULL
, return -ENXIO
);
946 mutex_lock(®ister_mutex
);
947 if (snd_pcm_search(pcm
->card
, pcm
->device
)) {
948 mutex_unlock(®ister_mutex
);
951 list_add_tail(&pcm
->list
, &snd_pcm_devices
);
952 for (cidx
= 0; cidx
< 2; cidx
++) {
954 if (pcm
->streams
[cidx
].substream
== NULL
)
957 case SNDRV_PCM_STREAM_PLAYBACK
:
958 sprintf(str
, "pcmC%iD%ip", pcm
->card
->number
, pcm
->device
);
959 devtype
= SNDRV_DEVICE_TYPE_PCM_PLAYBACK
;
961 case SNDRV_PCM_STREAM_CAPTURE
:
962 sprintf(str
, "pcmC%iD%ic", pcm
->card
->number
, pcm
->device
);
963 devtype
= SNDRV_DEVICE_TYPE_PCM_CAPTURE
;
966 /* device pointer to use, pcm->dev takes precedence if
967 * it is assigned, otherwise fall back to card's device
971 dev
= snd_card_get_device_link(pcm
->card
);
973 err
= snd_register_device_for_dev(devtype
, pcm
->card
,
975 &snd_pcm_f_ops
[cidx
],
978 list_del(&pcm
->list
);
979 mutex_unlock(®ister_mutex
);
982 snd_add_device_sysfs_file(devtype
, pcm
->card
, pcm
->device
,
984 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
)
985 snd_pcm_timer_init(substream
);
988 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
)
989 notify
->n_register(pcm
);
991 mutex_unlock(®ister_mutex
);
995 static int snd_pcm_dev_disconnect(struct snd_device
*device
)
997 struct snd_pcm
*pcm
= device
->device_data
;
998 struct snd_pcm_notify
*notify
;
999 struct snd_pcm_substream
*substream
;
1002 mutex_lock(®ister_mutex
);
1003 if (list_empty(&pcm
->list
))
1006 list_del_init(&pcm
->list
);
1007 for (cidx
= 0; cidx
< 2; cidx
++)
1008 for (substream
= pcm
->streams
[cidx
].substream
; substream
; substream
= substream
->next
)
1009 if (substream
->runtime
)
1010 substream
->runtime
->status
->state
= SNDRV_PCM_STATE_DISCONNECTED
;
1011 list_for_each_entry(notify
, &snd_pcm_notify_list
, list
) {
1012 notify
->n_disconnect(pcm
);
1014 for (cidx
= 0; cidx
< 2; cidx
++) {
1017 case SNDRV_PCM_STREAM_PLAYBACK
:
1018 devtype
= SNDRV_DEVICE_TYPE_PCM_PLAYBACK
;
1020 case SNDRV_PCM_STREAM_CAPTURE
:
1021 devtype
= SNDRV_DEVICE_TYPE_PCM_CAPTURE
;
1024 snd_unregister_device(devtype
, pcm
->card
, pcm
->device
);
1027 mutex_unlock(®ister_mutex
);
1031 int snd_pcm_notify(struct snd_pcm_notify
*notify
, int nfree
)
1033 struct snd_pcm
*pcm
;
1035 snd_assert(notify
!= NULL
&&
1036 notify
->n_register
!= NULL
&&
1037 notify
->n_unregister
!= NULL
&&
1038 notify
->n_disconnect
, return -EINVAL
);
1039 mutex_lock(®ister_mutex
);
1041 list_del(¬ify
->list
);
1042 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1043 notify
->n_unregister(pcm
);
1045 list_add_tail(¬ify
->list
, &snd_pcm_notify_list
);
1046 list_for_each_entry(pcm
, &snd_pcm_devices
, list
)
1047 notify
->n_register(pcm
);
1049 mutex_unlock(®ister_mutex
);
1053 EXPORT_SYMBOL(snd_pcm_notify
);
1055 #ifdef CONFIG_PROC_FS
1060 static void snd_pcm_proc_read(struct snd_info_entry
*entry
,
1061 struct snd_info_buffer
*buffer
)
1063 struct snd_pcm
*pcm
;
1065 mutex_lock(®ister_mutex
);
1066 list_for_each_entry(pcm
, &snd_pcm_devices
, list
) {
1067 snd_iprintf(buffer
, "%02i-%02i: %s : %s",
1068 pcm
->card
->number
, pcm
->device
, pcm
->id
, pcm
->name
);
1069 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
)
1070 snd_iprintf(buffer
, " : playback %i",
1071 pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream_count
);
1072 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
)
1073 snd_iprintf(buffer
, " : capture %i",
1074 pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream_count
);
1075 snd_iprintf(buffer
, "\n");
1077 mutex_unlock(®ister_mutex
);
1080 static struct snd_info_entry
*snd_pcm_proc_entry
;
1082 static void snd_pcm_proc_init(void)
1084 struct snd_info_entry
*entry
;
1086 if ((entry
= snd_info_create_module_entry(THIS_MODULE
, "pcm", NULL
)) != NULL
) {
1087 snd_info_set_text_ops(entry
, NULL
, snd_pcm_proc_read
);
1088 if (snd_info_register(entry
) < 0) {
1089 snd_info_free_entry(entry
);
1093 snd_pcm_proc_entry
= entry
;
1096 static void snd_pcm_proc_done(void)
1098 snd_info_free_entry(snd_pcm_proc_entry
);
1101 #else /* !CONFIG_PROC_FS */
1102 #define snd_pcm_proc_init()
1103 #define snd_pcm_proc_done()
1104 #endif /* CONFIG_PROC_FS */
1111 static int __init
alsa_pcm_init(void)
1113 snd_ctl_register_ioctl(snd_pcm_control_ioctl
);
1114 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl
);
1115 snd_pcm_proc_init();
1119 static void __exit
alsa_pcm_exit(void)
1121 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl
);
1122 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl
);
1123 snd_pcm_proc_done();
1126 module_init(alsa_pcm_init
)
1127 module_exit(alsa_pcm_exit
)