2 * Digital Audio (PCM) abstract layer
3 * Copyright (c) by Jaroslav Kysela <perex@suse.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@suse.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);
45 static int snd_pcm_dev_unregister(struct snd_device *device);
47 static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device)
52 list_for_each(p, &snd_pcm_devices) {
53 pcm = list_entry(p, struct snd_pcm, list);
54 if (pcm->card == card && pcm->device == device)
60 static int snd_pcm_control_ioctl(struct snd_card *card,
61 struct snd_ctl_file *control,
62 unsigned int cmd, unsigned long arg)
65 case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
69 if (get_user(device, (int __user *)arg))
71 mutex_lock(®ister_mutex);
72 device = device < 0 ? 0 : device + 1;
73 while (device < SNDRV_PCM_DEVICES) {
74 if (snd_pcm_search(card, device))
78 if (device == SNDRV_PCM_DEVICES)
80 mutex_unlock(®ister_mutex);
81 if (put_user(device, (int __user *)arg))
85 case SNDRV_CTL_IOCTL_PCM_INFO:
87 struct snd_pcm_info __user *info;
88 unsigned int device, subdevice;
91 struct snd_pcm_str *pstr;
92 struct snd_pcm_substream *substream;
95 info = (struct snd_pcm_info __user *)arg;
96 if (get_user(device, &info->device))
98 if (get_user(stream, &info->stream))
100 if (stream < 0 || stream > 1)
102 if (get_user(subdevice, &info->subdevice))
104 mutex_lock(®ister_mutex);
105 pcm = snd_pcm_search(card, device);
110 pstr = &pcm->streams[stream];
111 if (pstr->substream_count == 0) {
115 if (subdevice >= pstr->substream_count) {
119 for (substream = pstr->substream; substream;
120 substream = substream->next)
121 if (substream->number == (int)subdevice)
123 if (substream == NULL) {
127 err = snd_pcm_info_user(substream, info);
129 mutex_unlock(®ister_mutex);
132 case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
136 if (get_user(val, (int __user *)arg))
138 control->prefer_pcm_subdevice = val;
145 #ifdef CONFIG_SND_VERBOSE_PROCFS
147 #define STATE(v) [SNDRV_PCM_STATE_##v] = #v
148 #define STREAM(v) [SNDRV_PCM_STREAM_##v] = #v
149 #define READY(v) [SNDRV_PCM_READY_##v] = #v
150 #define XRUN(v) [SNDRV_PCM_XRUN_##v] = #v
151 #define SILENCE(v) [SNDRV_PCM_SILENCE_##v] = #v
152 #define TSTAMP(v) [SNDRV_PCM_TSTAMP_##v] = #v
153 #define ACCESS(v) [SNDRV_PCM_ACCESS_##v] = #v
154 #define START(v) [SNDRV_PCM_START_##v] = #v
155 #define FORMAT(v) [SNDRV_PCM_FORMAT_##v] = #v
156 #define SUBFORMAT(v) [SNDRV_PCM_SUBFORMAT_##v] = #v
158 static char *snd_pcm_format_names[] = {
177 FORMAT(IEC958_SUBFRAME_LE),
178 FORMAT(IEC958_SUBFRAME_BE),
199 static const char *snd_pcm_format_name(snd_pcm_format_t format)
201 return snd_pcm_format_names[format];
204 static char *snd_pcm_stream_names[] = {
209 static char *snd_pcm_state_names[] = {
220 static char *snd_pcm_access_names[] = {
221 ACCESS(MMAP_INTERLEAVED),
222 ACCESS(MMAP_NONINTERLEAVED),
223 ACCESS(MMAP_COMPLEX),
224 ACCESS(RW_INTERLEAVED),
225 ACCESS(RW_NONINTERLEAVED),
228 static char *snd_pcm_subformat_names[] = {
232 static char *snd_pcm_tstamp_mode_names[] = {
237 static const char *snd_pcm_stream_name(int stream)
239 snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL);
240 return snd_pcm_stream_names[stream];
243 static const char *snd_pcm_access_name(snd_pcm_access_t access)
245 return snd_pcm_access_names[access];
248 static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
250 return snd_pcm_subformat_names[subformat];
253 static const char *snd_pcm_tstamp_mode_name(int mode)
255 snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL);
256 return snd_pcm_tstamp_mode_names[mode];
259 static const char *snd_pcm_state_name(snd_pcm_state_t state)
261 return snd_pcm_state_names[state];
264 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
265 #include <linux/soundcard.h>
267 static const char *snd_pcm_oss_format_name(int format)
296 static void snd_pcm_proc_info_read(struct snd_pcm_substream *substream,
297 struct snd_info_buffer *buffer)
299 struct snd_pcm_info *info;
305 info = kmalloc(sizeof(*info), GFP_KERNEL);
307 printk(KERN_DEBUG "snd_pcm_proc_info_read: cannot malloc\n");
311 err = snd_pcm_info(substream, info);
313 snd_iprintf(buffer, "error %d\n", err);
317 snd_iprintf(buffer, "card: %d\n", info->card);
318 snd_iprintf(buffer, "device: %d\n", info->device);
319 snd_iprintf(buffer, "subdevice: %d\n", info->subdevice);
320 snd_iprintf(buffer, "stream: %s\n", snd_pcm_stream_name(info->stream));
321 snd_iprintf(buffer, "id: %s\n", info->id);
322 snd_iprintf(buffer, "name: %s\n", info->name);
323 snd_iprintf(buffer, "subname: %s\n", info->subname);
324 snd_iprintf(buffer, "class: %d\n", info->dev_class);
325 snd_iprintf(buffer, "subclass: %d\n", info->dev_subclass);
326 snd_iprintf(buffer, "subdevices_count: %d\n", info->subdevices_count);
327 snd_iprintf(buffer, "subdevices_avail: %d\n", info->subdevices_avail);
331 static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
332 struct snd_info_buffer *buffer)
334 snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
338 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
339 struct snd_info_buffer *buffer)
341 snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
345 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
346 struct snd_info_buffer *buffer)
348 struct snd_pcm_substream *substream = entry->private_data;
349 struct snd_pcm_runtime *runtime = substream->runtime;
351 snd_iprintf(buffer, "closed\n");
354 snd_pcm_stream_lock_irq(substream);
355 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
356 snd_iprintf(buffer, "no setup\n");
357 snd_pcm_stream_unlock_irq(substream);
360 snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
361 snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format));
362 snd_iprintf(buffer, "subformat: %s\n", snd_pcm_subformat_name(runtime->subformat));
363 snd_iprintf(buffer, "channels: %u\n", runtime->channels);
364 snd_iprintf(buffer, "rate: %u (%u/%u)\n", runtime->rate, runtime->rate_num, runtime->rate_den);
365 snd_iprintf(buffer, "period_size: %lu\n", runtime->period_size);
366 snd_iprintf(buffer, "buffer_size: %lu\n", runtime->buffer_size);
367 snd_iprintf(buffer, "tick_time: %u\n", runtime->tick_time);
368 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
369 if (substream->oss.oss) {
370 snd_iprintf(buffer, "OSS format: %s\n", snd_pcm_oss_format_name(runtime->oss.format));
371 snd_iprintf(buffer, "OSS channels: %u\n", runtime->oss.channels);
372 snd_iprintf(buffer, "OSS rate: %u\n", runtime->oss.rate);
373 snd_iprintf(buffer, "OSS period bytes: %lu\n", (unsigned long)runtime->oss.period_bytes);
374 snd_iprintf(buffer, "OSS periods: %u\n", runtime->oss.periods);
375 snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
378 snd_pcm_stream_unlock_irq(substream);
381 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
382 struct snd_info_buffer *buffer)
384 struct snd_pcm_substream *substream = entry->private_data;
385 struct snd_pcm_runtime *runtime = substream->runtime;
387 snd_iprintf(buffer, "closed\n");
390 snd_pcm_stream_lock_irq(substream);
391 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
392 snd_iprintf(buffer, "no setup\n");
393 snd_pcm_stream_unlock_irq(substream);
396 snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
397 snd_iprintf(buffer, "period_step: %u\n", runtime->period_step);
398 snd_iprintf(buffer, "sleep_min: %u\n", runtime->sleep_min);
399 snd_iprintf(buffer, "avail_min: %lu\n", runtime->control->avail_min);
400 snd_iprintf(buffer, "xfer_align: %lu\n", runtime->xfer_align);
401 snd_iprintf(buffer, "start_threshold: %lu\n", runtime->start_threshold);
402 snd_iprintf(buffer, "stop_threshold: %lu\n", runtime->stop_threshold);
403 snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
404 snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
405 snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
406 snd_pcm_stream_unlock_irq(substream);
409 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
410 struct snd_info_buffer *buffer)
412 struct snd_pcm_substream *substream = entry->private_data;
413 struct snd_pcm_runtime *runtime = substream->runtime;
414 struct snd_pcm_status status;
417 snd_iprintf(buffer, "closed\n");
420 memset(&status, 0, sizeof(status));
421 err = snd_pcm_status(substream, &status);
423 snd_iprintf(buffer, "error %d\n", err);
426 snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
427 snd_iprintf(buffer, "trigger_time: %ld.%09ld\n",
428 status.trigger_tstamp.tv_sec, status.trigger_tstamp.tv_nsec);
429 snd_iprintf(buffer, "tstamp : %ld.%09ld\n",
430 status.tstamp.tv_sec, status.tstamp.tv_nsec);
431 snd_iprintf(buffer, "delay : %ld\n", status.delay);
432 snd_iprintf(buffer, "avail : %ld\n", status.avail);
433 snd_iprintf(buffer, "avail_max : %ld\n", status.avail_max);
434 snd_iprintf(buffer, "-----\n");
435 snd_iprintf(buffer, "hw_ptr : %ld\n", runtime->status->hw_ptr);
436 snd_iprintf(buffer, "appl_ptr : %ld\n", runtime->control->appl_ptr);
439 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
440 static void snd_pcm_xrun_debug_read(struct snd_info_entry *entry,
441 struct snd_info_buffer *buffer)
443 struct snd_pcm_str *pstr = entry->private_data;
444 snd_iprintf(buffer, "%d\n", pstr->xrun_debug);
447 static void snd_pcm_xrun_debug_write(struct snd_info_entry *entry,
448 struct snd_info_buffer *buffer)
450 struct snd_pcm_str *pstr = entry->private_data;
452 if (!snd_info_get_line(buffer, line, sizeof(line)))
453 pstr->xrun_debug = simple_strtoul(line, NULL, 10);
457 static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
459 struct snd_pcm *pcm = pstr->pcm;
460 struct snd_info_entry *entry;
463 sprintf(name, "pcm%i%c", pcm->device,
464 pstr->stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
465 if ((entry = snd_info_create_card_entry(pcm->card, name, pcm->card->proc_root)) == NULL)
467 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
468 if (snd_info_register(entry) < 0) {
469 snd_info_free_entry(entry);
472 pstr->proc_root = entry;
474 if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
475 snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
476 if (snd_info_register(entry) < 0) {
477 snd_info_free_entry(entry);
481 pstr->proc_info_entry = entry;
483 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
484 if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
485 pstr->proc_root)) != NULL) {
486 entry->c.text.read = snd_pcm_xrun_debug_read;
487 entry->c.text.write = snd_pcm_xrun_debug_write;
488 entry->mode |= S_IWUSR;
489 entry->private_data = pstr;
490 if (snd_info_register(entry) < 0) {
491 snd_info_free_entry(entry);
495 pstr->proc_xrun_debug_entry = entry;
500 static int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr)
502 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
503 if (pstr->proc_xrun_debug_entry) {
504 snd_info_unregister(pstr->proc_xrun_debug_entry);
505 pstr->proc_xrun_debug_entry = NULL;
508 if (pstr->proc_info_entry) {
509 snd_info_unregister(pstr->proc_info_entry);
510 pstr->proc_info_entry = NULL;
512 if (pstr->proc_root) {
513 snd_info_unregister(pstr->proc_root);
514 pstr->proc_root = NULL;
519 static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
521 struct snd_info_entry *entry;
522 struct snd_card *card;
525 card = substream->pcm->card;
527 sprintf(name, "sub%i", substream->number);
528 if ((entry = snd_info_create_card_entry(card, name, substream->pstr->proc_root)) == NULL)
530 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
531 if (snd_info_register(entry) < 0) {
532 snd_info_free_entry(entry);
535 substream->proc_root = entry;
537 if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
538 snd_info_set_text_ops(entry, substream,
539 snd_pcm_substream_proc_info_read);
540 if (snd_info_register(entry) < 0) {
541 snd_info_free_entry(entry);
545 substream->proc_info_entry = entry;
547 if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
548 snd_info_set_text_ops(entry, substream,
549 snd_pcm_substream_proc_hw_params_read);
550 if (snd_info_register(entry) < 0) {
551 snd_info_free_entry(entry);
555 substream->proc_hw_params_entry = entry;
557 if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
558 snd_info_set_text_ops(entry, substream,
559 snd_pcm_substream_proc_sw_params_read);
560 if (snd_info_register(entry) < 0) {
561 snd_info_free_entry(entry);
565 substream->proc_sw_params_entry = entry;
567 if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
568 snd_info_set_text_ops(entry, substream,
569 snd_pcm_substream_proc_status_read);
570 if (snd_info_register(entry) < 0) {
571 snd_info_free_entry(entry);
575 substream->proc_status_entry = entry;
580 static int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream)
582 if (substream->proc_info_entry) {
583 snd_info_unregister(substream->proc_info_entry);
584 substream->proc_info_entry = NULL;
586 if (substream->proc_hw_params_entry) {
587 snd_info_unregister(substream->proc_hw_params_entry);
588 substream->proc_hw_params_entry = NULL;
590 if (substream->proc_sw_params_entry) {
591 snd_info_unregister(substream->proc_sw_params_entry);
592 substream->proc_sw_params_entry = NULL;
594 if (substream->proc_status_entry) {
595 snd_info_unregister(substream->proc_status_entry);
596 substream->proc_status_entry = NULL;
598 if (substream->proc_root) {
599 snd_info_unregister(substream->proc_root);
600 substream->proc_root = NULL;
604 #else /* !CONFIG_SND_VERBOSE_PROCFS */
605 static inline int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr) { return 0; }
606 static inline int snd_pcm_stream_proc_done(struct snd_pcm_str *pstr) { return 0; }
607 static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream) { return 0; }
608 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; }
609 #endif /* CONFIG_SND_VERBOSE_PROCFS */
612 * snd_pcm_new_stream - create a new PCM stream
613 * @pcm: the pcm instance
614 * @stream: the stream direction, SNDRV_PCM_STREAM_XXX
615 * @substream_count: the number of substreams
617 * Creates a new stream for the pcm.
618 * The corresponding stream on the pcm must have been empty before
619 * calling this, i.e. zero must be given to the argument of
622 * Returns zero if successful, or a negative error code on failure.
624 int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
627 struct snd_pcm_str *pstr = &pcm->streams[stream];
628 struct snd_pcm_substream *substream, *prev;
630 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
631 mutex_init(&pstr->oss.setup_mutex);
633 pstr->stream = stream;
635 pstr->substream_count = substream_count;
636 if (substream_count > 0) {
637 err = snd_pcm_stream_proc_init(pstr);
639 snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
644 for (idx = 0, prev = NULL; idx < substream_count; idx++) {
645 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
646 if (substream == NULL) {
647 snd_printk(KERN_ERR "Cannot allocate PCM substream\n");
650 substream->pcm = pcm;
651 substream->pstr = pstr;
652 substream->number = idx;
653 substream->stream = stream;
654 sprintf(substream->name, "subdevice #%i", idx);
655 substream->buffer_bytes_max = UINT_MAX;
657 pstr->substream = substream;
659 prev->next = substream;
660 err = snd_pcm_substream_proc_init(substream);
662 snd_printk(KERN_ERR "Error in snd_pcm_stream_proc_init\n");
666 substream->group = &substream->self_group;
667 spin_lock_init(&substream->self_group.lock);
668 INIT_LIST_HEAD(&substream->self_group.substreams);
669 list_add_tail(&substream->link_list, &substream->self_group.substreams);
670 spin_lock_init(&substream->timer_lock);
676 EXPORT_SYMBOL(snd_pcm_new_stream);
679 * snd_pcm_new - create a new PCM instance
680 * @card: the card instance
682 * @device: the device index (zero based)
683 * @playback_count: the number of substreams for playback
684 * @capture_count: the number of substreams for capture
685 * @rpcm: the pointer to store the new pcm instance
687 * Creates a new PCM instance.
689 * The pcm operators have to be set afterwards to the new instance
690 * via snd_pcm_set_ops().
692 * Returns zero if successful, or a negative error code on failure.
694 int snd_pcm_new(struct snd_card *card, char *id, int device,
695 int playback_count, int capture_count,
696 struct snd_pcm ** rpcm)
700 static struct snd_device_ops ops = {
701 .dev_free = snd_pcm_dev_free,
702 .dev_register = snd_pcm_dev_register,
703 .dev_disconnect = snd_pcm_dev_disconnect,
704 .dev_unregister = snd_pcm_dev_unregister
707 snd_assert(rpcm != NULL, return -EINVAL);
709 snd_assert(card != NULL, return -ENXIO);
710 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
712 snd_printk(KERN_ERR "Cannot allocate PCM\n");
716 pcm->device = device;
718 strlcpy(pcm->id, id, sizeof(pcm->id));
719 if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {
723 if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) {
727 mutex_init(&pcm->open_mutex);
728 init_waitqueue_head(&pcm->open_wait);
729 if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {
737 EXPORT_SYMBOL(snd_pcm_new);
739 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
741 struct snd_pcm_substream *substream, *substream_next;
742 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
743 struct snd_pcm_oss_setup *setup, *setupn;
745 substream = pstr->substream;
747 substream_next = substream->next;
748 snd_pcm_substream_proc_done(substream);
750 substream = substream_next;
752 snd_pcm_stream_proc_done(pstr);
753 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
754 for (setup = pstr->oss.setup_list; setup; setup = setupn) {
755 setupn = setup->next;
756 kfree(setup->task_name);
762 static int snd_pcm_free(struct snd_pcm *pcm)
764 snd_assert(pcm != NULL, return -ENXIO);
765 if (pcm->private_free)
766 pcm->private_free(pcm);
767 snd_pcm_lib_preallocate_free_for_all(pcm);
768 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK]);
769 snd_pcm_free_stream(&pcm->streams[SNDRV_PCM_STREAM_CAPTURE]);
774 static int snd_pcm_dev_free(struct snd_device *device)
776 struct snd_pcm *pcm = device->device_data;
777 return snd_pcm_free(pcm);
780 static void snd_pcm_tick_timer_func(unsigned long data)
782 struct snd_pcm_substream *substream = (struct snd_pcm_substream *) data;
783 snd_pcm_tick_elapsed(substream);
786 int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
788 struct snd_pcm_substream **rsubstream)
790 struct snd_pcm_str * pstr;
791 struct snd_pcm_substream *substream;
792 struct snd_pcm_runtime *runtime;
793 struct snd_ctl_file *kctl;
794 struct snd_card *card;
795 struct list_head *list;
796 int prefer_subdevice = -1;
799 snd_assert(rsubstream != NULL, return -EINVAL);
801 snd_assert(pcm != NULL, return -ENXIO);
802 pstr = &pcm->streams[stream];
803 if (pstr->substream == NULL || pstr->substream_count == 0)
807 down_read(&card->controls_rwsem);
808 list_for_each(list, &card->ctl_files) {
809 kctl = snd_ctl_file(list);
810 if (kctl->pid == current->pid) {
811 prefer_subdevice = kctl->prefer_pcm_subdevice;
815 up_read(&card->controls_rwsem);
818 case SNDRV_PCM_STREAM_PLAYBACK:
819 if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
820 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next) {
821 if (SUBSTREAM_BUSY(substream))
826 case SNDRV_PCM_STREAM_CAPTURE:
827 if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
828 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) {
829 if (SUBSTREAM_BUSY(substream))
838 if (prefer_subdevice >= 0) {
839 for (substream = pstr->substream; substream; substream = substream->next)
840 if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice)
843 for (substream = pstr->substream; substream; substream = substream->next)
844 if (!SUBSTREAM_BUSY(substream))
847 if (substream == NULL)
850 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
854 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
855 runtime->status = snd_malloc_pages(size, GFP_KERNEL);
856 if (runtime->status == NULL) {
860 memset((void*)runtime->status, 0, size);
862 size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
863 runtime->control = snd_malloc_pages(size, GFP_KERNEL);
864 if (runtime->control == NULL) {
865 snd_free_pages((void*)runtime->status,
866 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
870 memset((void*)runtime->control, 0, size);
872 init_waitqueue_head(&runtime->sleep);
873 atomic_set(&runtime->mmap_count, 0);
874 init_timer(&runtime->tick_timer);
875 runtime->tick_timer.function = snd_pcm_tick_timer_func;
876 runtime->tick_timer.data = (unsigned long) substream;
878 runtime->status->state = SNDRV_PCM_STATE_OPEN;
880 substream->runtime = runtime;
881 substream->private_data = pcm->private_data;
882 substream->ffile = file;
883 pstr->substream_opened++;
884 *rsubstream = substream;
888 void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
890 struct snd_pcm_runtime *runtime;
891 substream->file = NULL;
892 runtime = substream->runtime;
893 snd_assert(runtime != NULL, return);
894 if (runtime->private_free != NULL)
895 runtime->private_free(runtime);
896 snd_free_pages((void*)runtime->status,
897 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
898 snd_free_pages((void*)runtime->control,
899 PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)));
900 kfree(runtime->hw_constraints.rules);
902 substream->runtime = NULL;
903 substream->pstr->substream_opened--;
906 static int snd_pcm_dev_register(struct snd_device *device)
909 struct snd_pcm_substream *substream;
910 struct list_head *list;
912 struct snd_pcm *pcm = device->device_data;
914 snd_assert(pcm != NULL && device != NULL, return -ENXIO);
915 mutex_lock(®ister_mutex);
916 if (snd_pcm_search(pcm->card, pcm->device)) {
917 mutex_unlock(®ister_mutex);
920 list_add_tail(&pcm->list, &snd_pcm_devices);
921 for (cidx = 0; cidx < 2; cidx++) {
923 if (pcm->streams[cidx].substream == NULL)
926 case SNDRV_PCM_STREAM_PLAYBACK:
927 sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
928 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
930 case SNDRV_PCM_STREAM_CAPTURE:
931 sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
932 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
935 if ((err = snd_register_device(devtype, pcm->card,
937 &snd_pcm_f_ops[cidx],
940 list_del(&pcm->list);
941 mutex_unlock(®ister_mutex);
944 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
945 snd_pcm_timer_init(substream);
947 list_for_each(list, &snd_pcm_notify_list) {
948 struct snd_pcm_notify *notify;
949 notify = list_entry(list, struct snd_pcm_notify, list);
950 notify->n_register(pcm);
952 mutex_unlock(®ister_mutex);
956 static int snd_pcm_dev_disconnect(struct snd_device *device)
958 struct snd_pcm *pcm = device->device_data;
959 struct list_head *list;
960 struct snd_pcm_substream *substream;
963 mutex_lock(®ister_mutex);
964 list_del_init(&pcm->list);
965 for (cidx = 0; cidx < 2; cidx++)
966 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
967 if (substream->runtime)
968 substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
969 list_for_each(list, &snd_pcm_notify_list) {
970 struct snd_pcm_notify *notify;
971 notify = list_entry(list, struct snd_pcm_notify, list);
972 notify->n_disconnect(pcm);
974 mutex_unlock(®ister_mutex);
978 static int snd_pcm_dev_unregister(struct snd_device *device)
981 struct snd_pcm_substream *substream;
982 struct list_head *list;
983 struct snd_pcm *pcm = device->device_data;
985 snd_assert(pcm != NULL, return -ENXIO);
986 mutex_lock(®ister_mutex);
987 list_del(&pcm->list);
988 for (cidx = 0; cidx < 2; cidx++) {
991 case SNDRV_PCM_STREAM_PLAYBACK:
992 devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
994 case SNDRV_PCM_STREAM_CAPTURE:
995 devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
998 snd_unregister_device(devtype, pcm->card, pcm->device);
999 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
1000 snd_pcm_timer_done(substream);
1002 list_for_each(list, &snd_pcm_notify_list) {
1003 struct snd_pcm_notify *notify;
1004 notify = list_entry(list, struct snd_pcm_notify, list);
1005 notify->n_unregister(pcm);
1007 mutex_unlock(®ister_mutex);
1008 return snd_pcm_free(pcm);
1011 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
1013 struct list_head *p;
1015 snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL);
1016 mutex_lock(®ister_mutex);
1018 list_del(¬ify->list);
1019 list_for_each(p, &snd_pcm_devices)
1020 notify->n_unregister(list_entry(p,
1021 struct snd_pcm, list));
1023 list_add_tail(¬ify->list, &snd_pcm_notify_list);
1024 list_for_each(p, &snd_pcm_devices)
1025 notify->n_register(list_entry(p, struct snd_pcm, list));
1027 mutex_unlock(®ister_mutex);
1031 EXPORT_SYMBOL(snd_pcm_notify);
1033 #ifdef CONFIG_PROC_FS
1038 static void snd_pcm_proc_read(struct snd_info_entry *entry,
1039 struct snd_info_buffer *buffer)
1041 struct list_head *p;
1042 struct snd_pcm *pcm;
1044 mutex_lock(®ister_mutex);
1045 list_for_each(p, &snd_pcm_devices) {
1046 pcm = list_entry(p, struct snd_pcm, list);
1047 snd_iprintf(buffer, "%02i-%02i: %s : %s",
1048 pcm->card->number, pcm->device, pcm->id, pcm->name);
1049 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
1050 snd_iprintf(buffer, " : playback %i",
1051 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream_count);
1052 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
1053 snd_iprintf(buffer, " : capture %i",
1054 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count);
1055 snd_iprintf(buffer, "\n");
1057 mutex_unlock(®ister_mutex);
1060 static struct snd_info_entry *snd_pcm_proc_entry = NULL;
1062 static void snd_pcm_proc_init(void)
1064 struct snd_info_entry *entry;
1066 if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
1067 snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
1068 if (snd_info_register(entry) < 0) {
1069 snd_info_free_entry(entry);
1073 snd_pcm_proc_entry = entry;
1076 static void snd_pcm_proc_done(void)
1078 if (snd_pcm_proc_entry)
1079 snd_info_unregister(snd_pcm_proc_entry);
1082 #else /* !CONFIG_PROC_FS */
1083 #define snd_pcm_proc_init()
1084 #define snd_pcm_proc_done()
1085 #endif /* CONFIG_PROC_FS */
1092 static int __init alsa_pcm_init(void)
1094 snd_ctl_register_ioctl(snd_pcm_control_ioctl);
1095 snd_ctl_register_ioctl_compat(snd_pcm_control_ioctl);
1096 snd_pcm_proc_init();
1100 static void __exit alsa_pcm_exit(void)
1102 snd_ctl_unregister_ioctl(snd_pcm_control_ioctl);
1103 snd_ctl_unregister_ioctl_compat(snd_pcm_control_ioctl);
1104 snd_pcm_proc_done();
1107 module_init(alsa_pcm_init)
1108 module_exit(alsa_pcm_exit)